Skip to content

Commit 46decb3

Browse files
ewaostrowskaewaostrowska
committed
fix: add booleanSchemaValue to Schema's hashCode and equals
1 parent fbe8a8d commit 46decb3

File tree

2 files changed

+185
-3
lines changed
  • modules/swagger-models/src

2 files changed

+185
-3
lines changed

‎modules/swagger-models/src/main/java/io/swagger/v3/oas/models/media/Schema.java‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2155,8 +2155,8 @@ public boolean equals(java.lang.Object o) {
21552155
Objects.equals(this.$comment, schema.$comment) &&
21562156
Objects.equals(this.examples, schema.examples) &&
21572157
Objects.equals(this.prefixItems, schema.prefixItems) &&
2158-
Objects.equals(this.items, schema.items)
2159-
2158+
Objects.equals(this.items, schema.items) &&
2159+
Objects.equals(this.booleanSchemaValue, schema.booleanSchemaValue)
21602160
;
21612161
}
21622162

@@ -2169,7 +2169,7 @@ public int hashCode() {
21692169
discriminator, _enum, _default, patternProperties, $id, $anchor, $schema, $vocabulary, $dynamicAnchor,
21702170
$dynamicRef, types, allOf, anyOf, oneOf, _const, contentEncoding, contentMediaType, contentSchema,
21712171
propertyNames, unevaluatedProperties, maxContains, minContains, additionalItems, unevaluatedItems,
2172-
_if, _else, then, dependentRequired, dependentSchemas, $comment, examples, prefixItems, items);
2172+
_if, _else, then, dependentRequired, dependentSchemas, $comment, examples, prefixItems, items, booleanSchemaValue);
21732173
}
21742174

21752175
public java.util.Map<String, Object> getExtensions() {
@@ -2258,6 +2258,7 @@ public String toString() {
22582258
sb.append(" dependentSchemas: ").append(toIndentedString(dependentSchemas)).append("\n");
22592259
sb.append(" $comment: ").append(toIndentedString($comment)).append("\n");
22602260
sb.append(" prefixItems: ").append(toIndentedString(prefixItems)).append("\n");
2261+
sb.append(" booleanSchemaValue").append(toIndentedString(booleanSchemaValue)).append("\n");
22612262
}
22622263
sb.append("}");
22632264
return sb.toString();

‎modules/swagger-models/src/test/java/io/swagger/v3/oas/models/media/SchemaTest.java‎

Lines changed: 181 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,181 @@
1+
package io.swagger.v3.oas.models.media;
2+
3+
import org.testng.annotations.Test;
4+
import static org.testng.Assert.*;
5+
6+
import java.math.BigDecimal;
7+
import java.util.Arrays;
8+
import java.util.HashMap;
9+
import java.util.Map;
10+
11+
public class SchemaTest {
12+
13+
@Test
14+
public void testEqualsWithDifferentBooleanSchemaValue() {
15+
Schema<Object> schema1 = new Schema<>();
16+
Schema<Object> schema2 = new Schema<>();
17+
18+
schema1.setBooleanSchemaValue(true);
19+
schema2.setBooleanSchemaValue(false);
20+
21+
assertFalse(schema1.equals(schema2));
22+
assertFalse(schema2.equals(schema1));
23+
assertNotEquals(schema1.hashCode(), schema2.hashCode());
24+
}
25+
26+
27+
@Test
28+
public void testEqualsWithOneNullBooleanSchemaValue() {
29+
Schema<Object> schema1 = new Schema<>();
30+
Schema<Object> schema2 = new Schema<>();
31+
32+
schema1.setBooleanSchemaValue(true);
33+
schema2.setBooleanSchemaValue(null);
34+
35+
assertFalse(schema1.equals(schema2));
36+
assertFalse(schema2.equals(schema1));
37+
assertNotEquals(schema1.hashCode(), schema2.hashCode());
38+
}
39+
40+
@Test
41+
public void testBooleanSchemaValueFalseVsTrue() {
42+
// This test specifically addresses the issue where false gets mapped to true
43+
Schema<Object> schemaFalse = new Schema<>();
44+
Schema<Object> schemaTrue = new Schema<>();
45+
46+
schemaFalse.setBooleanSchemaValue(false);
47+
schemaTrue.setBooleanSchemaValue(true);
48+
49+
// These should be different
50+
assertFalse(schemaFalse.equals(schemaTrue));
51+
assertFalse(schemaTrue.equals(schemaFalse));
52+
53+
// Hash codes should be different to prevent collisions in maps
54+
assertNotEquals(schemaFalse.hashCode(), schemaTrue.hashCode());
55+
56+
// Verify the actual values
57+
assertEquals(Boolean.FALSE, schemaFalse.getBooleanSchemaValue());
58+
assertEquals(Boolean.TRUE, schemaTrue.getBooleanSchemaValue());
59+
}
60+
61+
@Test
62+
public void testComplexSchemaEqualsWithBooleanSchemaValue() {
63+
Schema<Object> schema1 = createComplexSchema();
64+
Schema<Object> schema2 = createComplexSchema();
65+
66+
// Initially they should be equal
67+
assertTrue(schema1.equals(schema2));
68+
assertEquals(schema1.hashCode(), schema2.hashCode());
69+
70+
// Change only booleanSchemaValue
71+
schema2.setBooleanSchemaValue(false);
72+
73+
// Now they should be different
74+
assertFalse(schema1.equals(schema2));
75+
assertNotEquals(schema1.hashCode(), schema2.hashCode());
76+
}
77+
78+
79+
@Test
80+
public void testBooleanSchemaValueInMapLookup() {
81+
Map<Schema<Object>, String> visitedMap = new HashMap<>();
82+
83+
Schema<Object> schemaTrue = new Schema<>();
84+
Schema<Object> schemaFalse = new Schema<>();
85+
86+
schemaTrue.setBooleanSchemaValue(true);
87+
schemaFalse.setBooleanSchemaValue(false);
88+
89+
visitedMap.put(schemaTrue, "true_schema");
90+
visitedMap.put(schemaFalse, "false_schema");
91+
92+
assertEquals(visitedMap.size(), 2);
93+
assertEquals(visitedMap.get(schemaTrue), "true_schema");
94+
assertEquals(visitedMap.get(schemaFalse), "false_schema");
95+
96+
Schema<Object> anotherTrue = new Schema<>();
97+
anotherTrue.setBooleanSchemaValue(true);
98+
assertEquals(visitedMap.get(anotherTrue), "true_schema");
99+
100+
Schema<Object> anotherFalse = new Schema<>();
101+
anotherFalse.setBooleanSchemaValue(false);
102+
assertEquals(visitedMap.get(anotherFalse), "false_schema");
103+
}
104+
105+
@Test
106+
public void testSchemaResolutionWithBooleanSchemaValue() {
107+
Map<Schema<Object>, Schema<Object>> visitedMap = new HashMap<>();
108+
109+
// Create a schema with booleanSchemaValue = false
110+
Schema<Object> originalSchema = new Schema<>();
111+
originalSchema.setBooleanSchemaValue(false);
112+
originalSchema.setTitle("Original Schema");
113+
originalSchema.setType("boolean");
114+
115+
// Create a resolved version of the same schema
116+
Schema<Object> resolvedSchema = new Schema<>();
117+
resolvedSchema.setBooleanSchemaValue(false);
118+
resolvedSchema.setTitle("Resolved Schema");
119+
resolvedSchema.setType("boolean");
120+
121+
// Put the original schema in the visited map
122+
visitedMap.put(originalSchema, resolvedSchema);
123+
124+
// Create another schema with identical structure but booleanSchemaValue = true
125+
Schema<Object> differentSchema = new Schema<>();
126+
differentSchema.setBooleanSchemaValue(true);
127+
differentSchema.setTitle("Original Schema");
128+
differentSchema.setType("boolean");
129+
130+
// The lookup should NOT return the resolved schema for the different schema
131+
assertNull(visitedMap.get(differentSchema));
132+
133+
// But it should return the resolved schema for an equivalent schema with false value
134+
Schema<Object> equivalentSchema = new Schema<>();
135+
equivalentSchema.setBooleanSchemaValue(false);
136+
equivalentSchema.setTitle("Original Schema");
137+
equivalentSchema.setType("boolean");
138+
assertEquals(resolvedSchema, visitedMap.get(equivalentSchema));
139+
140+
// Verify that the schemas with different booleanSchemaValue are indeed different
141+
assertNotEquals(originalSchema, differentSchema);
142+
assertNotEquals(originalSchema.hashCode(), differentSchema.hashCode());
143+
}
144+
145+
@Test
146+
public void testBooleanSchemaValueInSetOperations() {
147+
java.util.Set<Schema<Object>> schemaSet = new java.util.HashSet<>();
148+
149+
Schema<Object> schemaTrue = new Schema<>();
150+
schemaTrue.setBooleanSchemaValue(true);
151+
152+
Schema<Object> schemaFalse = new Schema<>();
153+
schemaFalse.setBooleanSchemaValue(false);
154+
155+
schemaSet.add(schemaTrue);
156+
schemaSet.add(schemaFalse);
157+
158+
// Should have two distinct schemas in the set
159+
assertEquals(schemaSet.size(), 2);
160+
assertTrue(schemaSet.contains(schemaTrue));
161+
assertTrue(schemaSet.contains(schemaFalse));
162+
163+
// Adding equivalent schemas should not increase the set size
164+
Schema<Object> anotherTrue = new Schema<>();
165+
anotherTrue.setBooleanSchemaValue(true);
166+
schemaSet.add(anotherTrue);
167+
assertEquals(schemaSet.size(), 2);
168+
}
169+
170+
private Schema<Object> createComplexSchema() {
171+
Schema<Object> schema = new Schema<>();
172+
schema.setTitle("Complex Schema");
173+
schema.setType("object");
174+
schema.setDescription("A complex schema for testing");
175+
schema.setMaximum(new BigDecimal("100"));
176+
schema.setMinimum(new BigDecimal("0"));
177+
schema.setRequired(Arrays.asList("id", "name"));
178+
schema.setBooleanSchemaValue(true);
179+
return schema;
180+
}
181+
}

0 commit comments

Comments
 (0)