DB.Migrator().AutoMigrate(&Preload{}, &Join{}, &Nested{}, &Value{})

	value1 := Value{
		Name: "value",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p1"}, {Value: "p2"},
			},
			Join: Join{Value: "j1"},
		},
	}
	value2 := Value{
		Name: "value2",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p3"}, {Value: "p4"}, {Value: "p5"},
			},

    assertEquals(expected, toTest);
  }

  public void testToStringLenient_addValue() {
    String toTest =
        MoreObjects.toStringHelper(new TestClass())
            .add("field1", 1)
            .addValue("value1")
            .add("field2", "value2")
            .addValue(2)
            .toString();
    String expected = ".*\\{field1\\=1, value1, field2\\=value2, 2\\}";

	want[0] = Level3{
		Level2: Level2{
			Level1s: []Level1{
				{Value: "value1"},
				{Value: "value2"},
			},
		},
		Level2_1: Level2_1{
			Level1s: []Level1{
				{
					Value:   "value1-1",
					Level0s: []Level0{{Value: "Level0-1"}},
				},
				{
					Value:   "value2-2",
					Level0s: []Level0{{Value: "Level0-2"}},
				},
			},
		},
	}

        MojoDescriptor mojoDescriptor = new MojoDescriptor();
        Parameter param1 = new Parameter();
        param1.setName("param1");
        param1.setDefaultValue("value1");
        mojoDescriptor.addParameter(param1);

        assertEquals(1, mojoDescriptor.getParameters().size());

        assertEquals(
                mojoDescriptor.getParameters().size(),

      }
    };
  }

  private static <T> ImmutableMultiset<T> multiset(T value, int count) {
    return multiset(ImmutableMap.of(value, count));
  }

  private static <T> ImmutableMultiset<T> multiset(T value1, int count1, T value2, int count2) {
    return multiset(ImmutableMap.of(value1, count1, value2, count2));
  }

  private static <T> ImmutableMultiset<T> multiset(Map<T, Integer> counts) {

      }
    };
  }

  private static <T> ImmutableMultiset<T> multiset(T value, int count) {
    return multiset(ImmutableMap.of(value, count));
  }

  private static <T> ImmutableMultiset<T> multiset(T value1, int count1, T value2, int count2) {
    return multiset(ImmutableMap.of(value1, count1, value2, count2));
  }

  private static <T> ImmutableMultiset<T> multiset(Map<T, Integer> counts) {

        // Add metadata
        data.addMetaData("key1", "value1");
        data.addMetaData("key2", 123);
        data.addMetaData("key3", true);

        Map<String, Object> metaDataMap = data.getMetaDataMap();
        assertNotNull(metaDataMap);
        assertEquals(3, metaDataMap.size());

        assertEquals("value1", metaDataMap.get("key1"));
        assertEquals(123, metaDataMap.get("key2"));

			accessKey:          creds.AccessKey,
			secretKey:          creds.SecretKey,
			body:               []byte(`<LifecycleConfiguration><Rule><ID>id</ID><Filter><Prefix>logs/</Prefix><Tag><Key>Key1</Key><Value>Value1</Value></Tag></Filter><Status>Enabled</Status><Expiration><Days>365</Days></Expiration></Rule></LifecycleConfiguration>`),
			expectedRespStatus: http.StatusBadRequest,
			lifecycleResponse:  []byte(``),

    @Test
    void testPropertiesClear() {
        // Test for issue #11552: NullPointerException when clearing properties
        Model model = new Model();
        model.addProperty("key1", "value1");
        model.addProperty("key2", "value2");
        assertEquals(2, model.getProperties().size());

        // This should not throw NullPointerException
        model.getProperties().clear();

        assertEquals("", queryLog.getFilterQueryString());
    }

    @Test
    public void test_complexQuery() throws Exception {
        String query = "field1:value1 AND field2:value2";
        String filterQuery = "category:electronics";
        QueryLog queryLog = new QueryLog(query, filterQuery);

        assertEquals(query, queryLog.getQueryString());