if product.Price != 150 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code not changed, price should not change
	DB.Model(&product).Updates(map[string]interface{}{"Name": "Product New"})

	if product.Name != "Product New" || product.Price != 160 || product.Code != "L1212" {

    assertThat(graph.removeEdge(2, 3)).isNull();
  }

  @Test
  public void removeEdge_directed_orderMismatch() {
    graph = ValueGraphBuilder.directed().build();
    graph.putEdgeValue(1, 2, "1->2");
    graph.putEdgeValue(2, 1, "2->1");
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> graph.removeEdge(EndpointPair.unordered(1, 2)));

    assertThat(graph.removeEdge(2, 3)).isNull();
  }

  @Test
  public void removeEdge_directed_orderMismatch() {
    graph = ValueGraphBuilder.directed().build();
    graph.putEdgeValue(1, 2, "1->2");
    graph.putEdgeValue(2, 1, "2->1");
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> graph.removeEdge(EndpointPair.unordered(1, 2)));

        assertThat(ArrayUtil.equalsIgnoreSequence(new Object[] { "1", "1" }, new Object[] { "1", "2" }), is(not(true)));
        assertThat(ArrayUtil.equalsIgnoreSequence(new Object[] { "1", "2", "1", "2" }, new Object[] { "2", "2", "1", "1" }), is(true));

        assertThat(ArrayUtil.equalsIgnoreSequence(null, null), is(true));
        assertThat(ArrayUtil.equalsIgnoreSequence(null, new Object[] {}), is(not(true)));

        Collections2.orderedPermutations(list, Ordering.natural()).iterator();

    assertNextPermutation(newArrayList(1, 1, 2, 2), permutations);
    assertNextPermutation(newArrayList(1, 2, 1, 2), permutations);
    assertNextPermutation(newArrayList(1, 2, 2, 1), permutations);
    assertNextPermutation(newArrayList(2, 1, 1, 2), permutations);
    assertNextPermutation(newArrayList(2, 1, 2, 1), permutations);

    testReverse(new byte[] {3, 1, 1}, 0, 2, new byte[] {1, 3, 1});
    testReverse(new byte[] {3, 1, 1}, 0, 1, new byte[] {3, 1, 1});
    testReverse(new byte[] {-1, 1, -2, 2}, 1, 3, new byte[] {-1, -2, 1, 2});
  }

  private static void testRotate(byte[] input, int distance, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Bytes.rotate(input, distance);

        Collections2.orderedPermutations(list, Ordering.natural()).iterator();

    assertNextPermutation(newArrayList(1, 1, 2, 2), permutations);
    assertNextPermutation(newArrayList(1, 2, 1, 2), permutations);
    assertNextPermutation(newArrayList(1, 2, 2, 1), permutations);
    assertNextPermutation(newArrayList(2, 1, 1, 2), permutations);
    assertNextPermutation(newArrayList(2, 1, 2, 1), permutations);

    testReverse(new double[] {3, 1, 1}, 0, 2, new double[] {1, 3, 1});
    testReverse(new double[] {3, 1, 1}, 0, 1, new double[] {3, 1, 1});
    testReverse(new double[] {-1, 1, -2, 2}, 1, 3, new double[] {-1, -2, 1, 2});
  }

  private static void testRotate(double[] input, int distance, double[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Doubles.rotate(input, distance);

    testReverse(new int[] {3, 1, 1}, 0, 2, new int[] {1, 3, 1});
    testReverse(new int[] {3, 1, 1}, 0, 1, new int[] {3, 1, 1});
    testReverse(new int[] {-1, 1, -2, 2}, 1, 3, new int[] {-1, -2, 1, 2});
  }

  private static void testRotate(int[] input, int distance, int[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Ints.rotate(input, distance);

    X1198,
    X1199,
    X1200,
    X1201,
    X1202,
    X1203,
    X1204,
    X1205,
    X1206,
    X1207,
    X1208,
    X1209,
    X1210,
    X1211,
    X1212,
    X1213,
    X1214,
    X1215,
    X1216,
    X1217,
    X1218,
    X1219,
    X1220,
    X1221,
    X1222,
    X1223,
    X1224,
    X1225,
    X1226,