text:
import {expect} from '@playwright/test';
import {getCaretPosition, sendKey} from '../../tools.po';
import {test, getPage, setPage} from '../../../../baseTest';
import {SELECTOR_HOUR, SELECTOR_MIN, SELECTOR_SEC} from '../timepicker.po';

const SELECTOR_BEFORE = '#before';
const SELECTOR_AFTER = '#after';

const focusInputBefore = async() => await getPage().click('#before');

test.use({testURL: 'timepicker/navigation', testSelector: 'h3:text("Timepicker navigation")'});
test.beforeEach(async({page}) => setPage(page));

test.describe('Timepicker', () => {

  async function expectCaretPosition(selector: string, position: number) {
    const {start, end} = await getCaretPosition(selector);
    expect(end, 'Caret should be at single position (no range selected)').toBe(end);
    expect(start, `Caret is not at proper position for given field`).toBe(position);
  }

  test.describe('navigation', () => {
    test(`should jump between inputs`, async() => {
      await focusInputBefore();

      await sendKey('Tab');
      await expect(getPage().locator(SELECTOR_HOUR), 'Hour field should be focused').toBeFocused();
      await sendKey('Tab');
      await expect(getPage().locator(SELECTOR_MIN), 'Minute field should be focused').toBeFocused();
      await sendKey('Tab');
      await expect(getPage().locator(SELECTOR_SEC), 'Second field should be focused').toBeFocused();
      await sendKey('Tab');
      await expect(getPage().locator(SELECTOR_AFTER), 'Input after should be focused').toBeFocused();

      await sendKey('Shift+Tab');
      await expect(getPage().locator(SELECTOR_SEC), 'Second field should be focused').toBeFocused();
      await sendKey('Shift+Tab');
      await expect(getPage().locator(SELECTOR_MIN), 'Minute field should be focused').toBeFocused();
      await sendKey('Shift+Tab');
      await expect(getPage().locator(SELECTOR_HOUR), 'Hour field should be focused').toBeFocused();
      await sendKey('Shift+Tab');
      await expect(getPage().locator(SELECTOR_BEFORE), 'Input before should be focused').toBeFocused();
    });
  });

  test.describe('arrow keys', () => {
    test.skip(({browserName}) => browserName === 'firefox' || browserName === 'webkit');

    test(`should keep caret at the end of the input`, async() => {
      for (const selector of[SELECTOR_HOUR, SELECTOR_MIN, SELECTOR_SEC]) {
        await getPage().click(selector);

        const expectCaretAtEnd = () => expectCaretPosition(selector, 2);

        await sendKey('End');
        await expectCaretAtEnd();

        await sendKey('ArrowUp');
        await expectCaretAtEnd();

        await sendKey('ArrowDown');
        await expectCaretAtEnd();

        await sendKey('Home');
        await expectCaretPosition(selector, 0);

        await sendKey('ArrowUp');
        await expectCaretAtEnd();

        await sendKey('ArrowDown');
        await expectCaretAtEnd();
      }
    });
  });

});


text:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MemoryOS
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

        }

        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {

        }

        private void label1_Click(object sender, EventArgs e)
        {

        }

        private void next_Click(object sender, EventArgs e)
        {
            if (numericUpDown1.Value != 0 && holes.RowCount > 1)
            {
                LinkedList<Hole> holesData = new LinkedList<Hole>();
                int rownums = holes.RowCount , errors = 0;
                int numOfProcess = int.Parse(numericUpDown1.Value.ToString());
                for (int i = 0; i < rownums - 1; i++)
                {
                    if (holes.Rows[i].Cells[1].Value == null || holes.Rows[i].Cells[0].Value == null)
                    {
                        MessageBox.Show("Error on enterng data");
                        errors += 1;
                    }
                    else
                    {

                        holesData.AddLast(new Hole(i, int.Parse(holes.Rows[i].Cells[0].Value.ToString()), int.Parse(holes.Rows[i].Cells[1].Value.ToString()), int.Parse(holes.Rows[i].Cells[0].Value.ToString())));
                    }
                }
                if (errors == 0)
                {
                    Form2 nextForm = new Form2(numOfProcess, holesData);
                    nextForm.Show();
                    this.Hide();
                }
            }
            else {
                MessageBox.Show("Please Add number of Processes above zero Or Add Holes");
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void label1_Click_1(object sender, EventArgs e)
        {

        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.apache.hadoop.hbase.snapshot;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.HRegionInfo;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.master.HMaster;
import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription;
import org.apache.hadoop.hbase.protobuf.generated.MasterAdminProtos.IsSnapshotDoneRequest;
import org.apache.hadoop.hbase.protobuf.generated.MasterAdminProtos.IsSnapshotDoneResponse;
import org.apache.hadoop.hbase.regionserver.HRegion;
import org.apache.hadoop.hbase.server.snapshot.TakeSnapshotUtils;
import org.apache.hadoop.hbase.snapshot.exception.HBaseSnapshotException;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.util.FSTableDescriptors;
import org.junit.Assert;

import com.google.protobuf.ServiceException;

/**
 * Utilities class for snapshots
 */
public class SnapshotTestingUtils {

  private static final Log LOG = LogFactory.getLog(SnapshotTestingUtils.class);

  /**
   * Assert that we don't have any snapshots lists
   * @throws IOException if the admin operation fails
   */
  public static void assertNoSnapshots(HBaseAdmin admin) throws IOException {
    assertEquals("Have some previous snapshots", 0, admin.listSnapshots().size());
  }

  /**
   * Make sure that there is only one snapshot returned from the master and its name and table match
   * the passed in parameters.
   */
  public static void assertOneSnapshotThatMatches(HBaseAdmin admin, SnapshotDescription snapshot)
      throws IOException {
    assertOneSnapshotThatMatches(admin, snapshot.getName(), snapshot.getTable());
  }

  /**
   * Make sure that there is only one snapshot returned from the master and its name and table match
   * the passed in parameters.
   */
  public static List<SnapshotDescription> assertOneSnapshotThatMatches(HBaseAdmin admin,
      String snapshotName, String tableName) throws IOException {
    // list the snapshot
    List<SnapshotDescription> snapshots = admin.listSnapshots();

    assertEquals("Should only have 1 snapshot", 1, snapshots.size());
    assertEquals(snapshotName, snapshots.get(0).getName());
    assertEquals(tableName, snapshots.get(0).getTable());

    return snapshots;
  }

  /**
   * Make sure that there is only one snapshot returned from the master and its name and table match
   * the passed in parameters.
   */
  public static List<SnapshotDescription> assertOneSnapshotThatMatches(HBaseAdmin admin,
      byte[] snapshot, byte[] tableName) throws IOException {
    return assertOneSnapshotThatMatches(admin, Bytes.toString(snapshot), Bytes.toString(tableName));
  }

  /**
   * Confirm that the snapshot contains references to all the files that should be in the snapshot
   */
  public static void confirmSnapshotValid(SnapshotDescription snapshotDescriptor, byte[] tableName,
      byte[] testFamily, Path rootDir, HBaseAdmin admin, FileSystem fs, boolean requireLogs,
      Path logsDir)
      throws IOException {
    Path snapshotDir = SnapshotDescriptionUtils
        .getCompletedSnapshotDir(snapshotDescriptor, rootDir);
    assertTrue(fs.exists(snapshotDir));
    Path snapshotinfo = new Path(snapshotDir, SnapshotDescriptionUtils.SNAPSHOTINFO_FILE);
    assertTrue(fs.exists(snapshotinfo));
    // check the logs dir
    if (requireLogs) {
      TakeSnapshotUtils.verifyAllLogsGotReferenced(fs,
        logsDir, snapshotDescriptor, new Path(snapshotDir, HConstants.HREGION_LOGDIR_NAME));
    }
    // check the table info
    HTableDescriptor desc = FSTableDescriptors.getTableDescriptor(fs, rootDir, tableName);
    HTableDescriptor snapshotDesc = FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
    assertEquals(desc, snapshotDesc);

    // check the region snapshot for all the regions
    List<HRegionInfo> regions = admin.getTableRegions(tableName);
    for (HRegionInfo info : regions) {
      String regionName = info.getEncodedName();
      Path regionDir = new Path(snapshotDir, regionName);
      HRegionInfo snapshotRegionInfo = HRegion.loadDotRegionInfoFileContent(fs, regionDir);
      assertEquals(info, snapshotRegionInfo);
      // check to make sure we have the family
      Path familyDir = new Path(regionDir, Bytes.toString(testFamily));
      assertTrue(fs.exists(familyDir));
      // make sure we have some files references
      assertTrue(fs.listStatus(familyDir).length > 0);
    }
  }

  /**
   * Helper method for testing async snapshot operations. Just waits for the given snapshot to
   * complete on the server by repeatedly checking the master.
   * @param master running the snapshot
   * @param snapshot to check
   * @param sleep amount to sleep between checks to see if the snapshot is done
   * @throws ServiceException if the snapshot fails
   */
  public static void waitForSnapshotToComplete(HMaster master, SnapshotDescription snapshot,
      long sleep) throws ServiceException {
    final IsSnapshotDoneRequest request = IsSnapshotDoneRequest.newBuilder().setSnapshot(snapshot)
        .build();
    IsSnapshotDoneResponse done = IsSnapshotDoneResponse.newBuilder().buildPartial();
    while (!done.getDone()) {
      done = master.isSnapshotDone(null, request);
      try {
        Thread.sleep(sleep);
      } catch (InterruptedException e) {
        throw new ServiceException(e);
      }
    }
  }

  public static void cleanupSnapshot(HBaseAdmin admin, byte[] tableName) throws IOException {
    SnapshotTestingUtils.cleanupSnapshot(admin, Bytes.toString(tableName));
  }

  public static void cleanupSnapshot(HBaseAdmin admin, String snapshotName) throws IOException {
    // delete the taken snapshot
    admin.deleteSnapshot(snapshotName);
    assertNoSnapshots(admin);
  }

  /**
   * Expect the snapshot to throw an error when checking if the snapshot is complete
   * @param master master to check
   * @param snapshot the {@link SnapshotDescription} request to pass to the master
   * @param clazz expected exception from the master
   */
  public static void expectSnapshotDoneException(HMaster master, IsSnapshotDoneRequest snapshot,
      Class<? extends HBaseSnapshotException> clazz) {
    try {
      master.isSnapshotDone(null, snapshot);
      Assert.fail("didn't fail to lookup a snapshot");
    } catch (ServiceException se) {
      try {
        throw ProtobufUtil.getRemoteException(se);
      } catch (HBaseSnapshotException e) {
        assertEquals("Threw wrong snapshot exception!", clazz, e.getClass());
      } catch (Throwable t) {
        Assert.fail("Threw an unexpected exception:" + t);
      }
    }
  }
}


text:
package io.github.xinyangpan.persistent.dao;

import org.springframework.data.repository.PagingAndSortingRepository;

import io.github.xinyangpan.persistent.po.GroupPo;

public interface GroupDao extends PagingAndSortingRepository<GroupPo, Long> {

}


text:
package com.ait.toolkit.titanium.mobile.client.core.json;

/**
 * Function to filter and transform the results passed to the JSON.parse() method.
 */
public interface Reviver {
	public String evaluate(String key, String value);
}


text:
<title>Plane Game</title>
<link type="text/css" rel="stylesheet" href="style.css" />