t.Fatalf("Failed to commit, got error %v", err)
	}

	if err := DB.First(&User{}, "name = ?", user.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}

	if err := DB.First(&User{}, "name = ?", user1.Name).Error; err == nil {
		t.Fatalf("Should not find rollbacked record")
	}

	if err := DB.First(&User{}, "name = ?", user2.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}

  val android5 = sslLabsClients.first { it.userAgent == "Android" && it.version == "5.0.0" }
  val android9 = sslLabsClients.first { it.userAgent == "Android" && it.version == "9.0" }
  val chrome33 = sslLabsClients.first { it.userAgent == "Chrome" && it.version == "33" }
  val chrome57 = sslLabsClients.first { it.userAgent == "Chrome" && it.version == "57" }
  val chrome80 = sslLabsClients.first { it.userAgent == "Chrome" && it.version == "80" }

     * @param first
     *            The first value
     * @param second
     *            The second value
     */
    public Pair(final T1 first, final T2 second) {
        this.first = first;
        this.second = second;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getFirst() {
        return first;
    }

    /**
     * Sets the first value.

      int[] allRequired, int requiredFrom, int requiredTo, double[] array, int from, int to) {
    // Choose the first selection to do...
    int requiredChosen = chooseNextSelection(allRequired, requiredFrom, requiredTo, from, to);
    int required = allRequired[requiredChosen];

    // ...do the first selection...
    selectInPlace(required, array, from, to);

  fun emptyCache(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    cache.close()
    assertJournalEquals()
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun recoverFromInitializationFailure(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)

/**
 * A tuple of three values.
 *
 * @author koichik
 * @param <T1>
 *            The type of the first value
 * @param <T2>
 *            The type of the second value
 * @param <T3>
 *            The type of the third value
 */
public class Tuple3<T1, T2, T3> {

    /** The first value */
    protected T1 value1;

    /** The second value */
    protected T2 value2;

    /** The third value */

                return mockResource1;
            }
        };

        // When/Then
        assertTrue(iterator.hasNext(), "Should have first element");
        SmbResource first = iterator.next();
        assertNotNull(first, "First element should not be null");
        assertEquals("file1.txt", first.getName());

        assertTrue(iterator.hasNext(), "Should have second element");
        SmbResource second = iterator.next();

		}
		lastUpdatedAt = n
	}

	checkOtherData := func(name string) {
		var first, last User
		if err := DB.Where("id = ?", users[0].ID).First(&first).Error; err != nil {
			t.Errorf("errors happened when query before user: %v", err)
		}
		CheckUser(t, first, *users[0])

		if err := DB.Where("id = ?", users[2].ID).First(&last).Error; err != nil {
			t.Errorf("errors happened when query after user: %v", err)
		}

   * first pre-determined printing line on the next form or page. (Applicable also to display
   * devices.)
   *
   * @since 8.0
   */
  public static final byte FF = 12;

  /**
   * Carriage Return ('\r'): A format effector which controls the movement of the printing position

    checkMessage(
        expected, "OtherOrder.FIRST -> MyOrder.THIRD", "MyOrder.THIRD -> OtherOrder.FIRST");
    lockA.lock();
    lock01.unlock();
    lockB.lock();
    lockA.unlock();

    expected = assertThrows(PotentialDeadlockException.class, () -> lock01.lock());
    checkMessage(
        expected, "LockB -> OtherOrder.FIRST", "LockA -> LockB", "OtherOrder.FIRST -> LockA");
  }