CacheBuilder<?, ?> expected, CacheBuilder<?, ?> actual) {
    assertWithMessage("concurrencyLevel")
        .that(actual.concurrencyLevel)
        .isEqualTo(expected.concurrencyLevel);
    assertWithMessage("expireAfterAccessNanos")
        .that(actual.expireAfterAccessNanos)
        .isEqualTo(expected.expireAfterAccessNanos);
    assertWithMessage("expireAfterWriteNanos")
        .that(actual.expireAfterWriteNanos)

    assertEquals(expected.toString(), actual.toString());
    assertEquals(actual.toString(), expected.hashCode(), actual.hashCode());
    assertThat(actual.getLowerBounds())
        .asList()
        .containsExactlyElementsIn(asList(expected.getLowerBounds()))
        .inOrder();
    assertThat(actual.getUpperBounds())
        .asList()

				Values:  [][]interface{}{{true}},
			},
		},
	}

	for _, tc := range testCase {
		t.Run(tc.name, func(t *testing.T) {
			actual := ConvertMapToValuesForCreate(&gorm.Statement{}, tc.input)
			if !reflect.DeepEqual(actual, tc.expect) {
				t.Errorf("expect %v got %v", tc.expect, actual)
			}
		})
	}
}

func TestConvertSliceOfMapToValuesForCreate(t *testing.T) {
	testCase := []struct {
		name   string

class ProjectBuildingResultWithLocationAssert {
    private final ProjectBuildingResult actual;

    ProjectBuildingResultWithLocationAssert(ProjectBuildingResult actual) {
        this.actual = actual;
    }

    public static ProjectBuildingResultWithLocationAssert assertThat(ProjectBuildingResult actual) {
        return new ProjectBuildingResultWithLocationAssert(actual);
    }

        String actual = response.toString();
        assertTrue(actual.startsWith("Trans2FindFirst2Response["));
        assertTrue(actual.contains("sid=123"));
        assertTrue(actual.contains("searchCount=5"));
        assertTrue(actual.contains("isEndOfSearch=true"));
        assertTrue(actual.contains("lastName=file5.txt"));
        assertTrue(actual.endsWith("]"));
    }

    @Test

        assembler.assembleModelInheritance(assembled, parent, null, problems);

        // write baseName + "-actual"
        File actual = new File(
                "target/test-classes/poms/inheritance/" + baseName + (fromRepo ? "-build" : "-repo") + "-actual.xml");
        writer.write(actual, null, assembled);

        // check with getPom( baseName + "-expected" )
        File expected = getPom(baseName + "-expected");

        String expected;
        String actual;
        String value;

        value = "hoge.txt";
        expected = "hoge.txt";
        actual = extractor.getFileName(value);
        assertEquals(expected, actual);

        value = "/hoge.txt";
        expected = "hoge.txt";
        actual = extractor.getFileName(value);
        assertEquals(expected, actual);

        value = "fuga/hoge.txt";

    @ParameterizedTest(name = "encode({1}) -> {2}")
    @MethodSource("encodeProvider")
    void testEncode(byte[] input, String expected) {
        // Arrange & Act
        String actual = Base64.encode(input);
        // Assert
        assertEquals(expected, actual, "Base64.encode should match expected string");
    }

    /**
     * Data provider for Base64 strings and expected decoded byte arrays.
     */

    if (actual instanceof Collection) {
      contained = ((Collection<?>) actual).contains(expected);
    } else {
      for (Object o : actual) {
        if (equal(o, expected)) {
          contained = true;
          break;
        }
      }
    }

    if (!contained) {
      fail("Not true that " + actual + " contains " + expected);
    }
  }

     * <li>If <code>type</code> is an array, the actual class of its elements is returned.</li>
     * <li>Otherwise, <code>null</code> is returned.</li>
     * </ul>
     *
     * @param type
     *            the type to analyze
     * @param map
     *            the map that contains the type variables and type arguments