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

				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

  public void testToArray_noArg() {
    Object[] actual = getList().toArray();
    assertArrayEquals("toArray() order should match list", createOrderedArray(), actual);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }

	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.String())
		if err != nil {
			t.Fatalf("Test %d: parse restore object failed: %v", i+1, err)
		}
		if actual.ongoing != tc.ongoing || actual.expiry.Format(http.TimeFormat) != tc.expiry.Format(http.TimeFormat) {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc)
		}
	}
}

     * <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

    @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.
     */

        int expected = Byte.compare(x, y);
        int actual = SignedBytes.compare(x, y);
        if (expected == 0) {
          assertWithMessage(x + ", " + y).that(actual).isEqualTo(expected);
        } else if (expected < 0) {
          assertWithMessage(x + ", " + y + " (expected: " + expected + ", actual" + actual + ")")
              .that(actual < 0)
              .isTrue();
        } else {

      fail("size mismatch: " + reportContext(expectedList));
    }
    for (int i = 0; i < expectedList.size(); i++) {
      E expected = expectedList.get(i);
      E actual = getList().get(i);
      if (expected != actual && (expected == null || !expected.equals(actual))) {
        fail("mismatch at index " + i + ": " + reportContext(expectedList));
      }
    }
  }

  /**

	}
	CheckIndices(t, expectedIndices, indices)
}

func CheckIndices(t *testing.T, expected, actual []*schema.Index) {
	if len(expected) != len(actual) {
		t.Errorf("expected %d indices, but got %d", len(expected), len(actual))
		return
	}

	for i, ei := range expected {
		t.Run(ei.Name, func(t *testing.T) {
			ai := actual[i]
			tests.AssertObjEqual(t, ai, ei, "Name", "Class", "Type", "Where", "Comment", "Option")

 */
package okhttp3.internal.platform

import android.content.Context
import android.os.Build
import java.lang.IllegalStateException
import okhttp3.internal.platform.android.AndroidLog

actual object PlatformRegistry {
  actual fun findPlatform(): Platform {
    AndroidLog.enable()

    val androidPlatform =
      Android10Platform.buildIfSupported()
        ?: AndroidPlatform.buildIfSupported()