name: OSV-Scanner Scheduled Scan

on:
  schedule:
    - cron: 0 4 * * 1

permissions:
  # Require writing security events to upload SARIF file to security tab
  security-events: write
  # Only need to read contents
  contents: read

jobs:
  scan-scheduled:
    if: github.repository == 'tensorflow/tensorflow'
    uses: "google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@v2.2.2"
    with:
      scan-args: |-

    /**
     * RDMA transform capabilities flag indicating response is requested
     */
    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;

    /**
     * Default maximum size for RDMA read/write operations (1MB)
     */
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576; // 1MB

    /**
     * Default maximum number of receive credits
     */

type result struct {
	dir     string
	entries []string
}

// Test to read empty directory.
func setupTestReadDirEmpty(t *testing.T) (testResults []result) {
	// Add empty entry slice for this test directory.
	testResults = append(testResults, result{t.TempDir(), []string{}})
	return testResults
}

// Test to read non-empty directory with only files.
func setupTestReadDirFiles(t *testing.T) (testResults []result) {

  public RandomAmountInputStream(InputStream in, Random random) {
    super(checkNotNull(in));
    this.random = checkNotNull(random);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return super.read(b, off, random.nextInt(len) + 1);
  }

	mr      *msgp.Reader
	current metaCacheEntry
	err     error // stateful error
	closer  func()
	creator func() error
}

// newMetacacheReader creates a new cache reader.
// Nothing will be read from the stream yet.
func newMetacacheReader(r io.Reader) *metacacheReader {
	dec := s2DecPool.Get()
	dec.Reset(r)
	mr := msgpNewReader(dec)
	return &metacacheReader{
		mr: mr,
		closer: func() {

    /**
     * Read bytes from the input stream into a buffer
     *
     * @param in the input stream to read from
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the number of bytes to read
     * @return number of bytes read
     * @throws IOException if an I/O error occurs
     */

        byte[] buffer = new byte[10];

        // When
        int bytesRead = trans.readSetupWireFormat(buffer, 0, 10);

        // Then
        assertEquals(0, bytesRead, "Should read 0 bytes.");
    }

    /**
     * Tests the readParametersWireFormat method.
     */
    @Test
    void testReadParametersWireFormat() {
        // Given

     if (all disks return format.json not found)
        return error
     else (some disks return format.json not found)
        (heal format)
        return
     fi
   fi
else
   if (some disks return format.json not found)
        // Offline disks are marked as dead.
        (heal format) // Offline disks should be marked as dead.
        return success
   fi
fi
*/

		return &uni, stmt.Table
	}

	getTable := func(rel *schema.Relationship) string {
		switch rel.Type {
		case schema.HasOne, schema.HasMany:
			return rel.FieldSchema.Table
		case schema.Many2Many:
			return rel.JoinTable.Table
		}
		return stmt.Table
	}

	for _, rel := range stmt.Schema.Relationships.Relations {
		if constraint := rel.ParseConstraint(); constraint != nil && constraint.Name == name {

    }

    /**
     * Returns the number of bytes available to read.
     * @return the number of available bytes
     * @throws IOException if an I/O error occurs
     */
    public int available() throws IOException {
        return this.dis.available();
    }

    /**
     * Reads bytes into the specified array.
     * @param b the byte array to read into
     * @throws IOException if an I/O error occurs
     */