expected[b][i] = expected[b][bit] ^ expected[b][i ^ bit];
        }
      }
    }

    int[][] actual = Crc32cHashFunction.Crc32cHasher.strideTable;
    assertTrue(
        "Expected: \n"
            + Arrays.deepToString(expected)
            + "\nActual:\n"
            + Arrays.deepToString(actual),
        Arrays.deepEquals(expected, actual));
  }

    out.write(bytes, 4, 2);
    byte[] expected = {bytes[4], bytes[5]};
    assertThat(out.toByteArray()).isEqualTo(expected);
  }

  public void testNewDataOutput_writeBoolean() {
    ByteArrayDataOutput out = ByteStreams.newDataOutput();
    out.writeBoolean(true);
    out.writeBoolean(false);
    byte[] expected = {(byte) 1, (byte) 0};
    assertThat(out.toByteArray()).isEqualTo(expected);
  }

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

    ExecutionException expected = assertThrows(ExecutionException.class, () -> getDone(future));
    assertThat(expected.getCause()).isEqualTo(exception);

    expected = assertThrows(ExecutionException.class, () -> getDoneFromTimeoutOverload(future));
    assertThat(expected.getCause()).isEqualTo(exception);
  }

  }

  private static void assertSip(String input, long expected) {
    assertEquals(expected, SIP_WITH_KEY.hashString(input, UTF_8).asLong());
    assertEquals(expected, SIP_WITH_KEY.newHasher().putString(input, UTF_8).hash().asLong());
    assertEquals(expected, SIP_WITHOUT_KEY.hashString(input, UTF_8).asLong());
    assertEquals(expected, SIP_WITHOUT_KEY.newHasher().putString(input, UTF_8).hash().asLong());
  }

  }

  private static void assertSip(String input, long expected) {
    assertEquals(expected, SIP_WITH_KEY.hashString(input, UTF_8).asLong());
    assertEquals(expected, SIP_WITH_KEY.newHasher().putString(input, UTF_8).hash().asLong());
    assertEquals(expected, SIP_WITHOUT_KEY.hashString(input, UTF_8).asLong());
    assertEquals(expected, SIP_WITHOUT_KEY.newHasher().putString(input, UTF_8).hash().asLong());
  }

      Random random = new Random();
      byte[] expected = factory.getExpected(bytes);
      // if expected.length == 0, off has to be 0 but length doesn't matter--result will be empty
      int off = expected.length == 0 ? 0 : random.nextInt(expected.length);
      int len = expected.length == 0 ? 4 : random.nextInt(expected.length - off);

            .add("field2", "value2");
    String expected = "TestClass{field1=1, value1, field2=value2}";

    assertThat(helper.toString()).isEqualTo(expected);
    // Call toString again
    assertThat(helper.toString()).isEqualTo(expected);

    // Make sure the cached value is reset when we modify the helper at all
    String expected2 = "TestClass{field1=1, value1, field2=value2, 2}";
    helper.addValue(2);

	if err := gorm.G[withResultUser](db, r).Create(ctx, &u); err != nil {
		t.Fatalf("create failed: %v", err)
	}
	if u.ID == 0 {
		t.Fatalf("expected ID to be set")
	}
	if r.Error != nil {
		t.Fatalf("unexpected result error: %v", r.Error)
	}
	if r.RowsAffected <= 0 {
		t.Fatalf("expected RowsAffected > 0, got %d", r.RowsAffected)
	}

	u2 := withResultUser{Name: "with-result-fail"}
	r2 := gorm.WithResult()

			trimLen:  5,
			expected: []int{},
		},
		{
			name:     "Zero trim length",
			input:    []int{1, 2, 3},
			trimLen:  0,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim one element from end",
			input:    []int{1, 2, 3},
			trimLen:  1,
			expected: []int{1, 2},
		},
		{
			name:     "Empty slice",
			input:    []int{},
			trimLen:  2,
			expected: []int{},
		},
		{