// https://cs.opensource.google/go/x/crypto/+/refs/tags/v0.22.0:ssh/common.go;l=85
var supportedMACs = []string{
	"******@****.***", "hmac-sha2-512******@****.***", "hmac-sha2-256", "hmac-sha2-512", "hmac-sha1", "hmac-sha1-96",
}

func sshPubKeyAuth(c ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
	return authenticateSSHConnection(c, key, nil)
}

    private static final int DEFAULT_MAX_DATA_COUNT =
            Config.getInt( "jcifs.smb1.smb.client.transaction_buf_size",
                    SmbComTransaction.TRANSACTION_BUF_SIZE ) - 512;

    // relative to headerStart
    private static final int PRIMARY_SETUP_OFFSET        = 61;
    private static final int SECONDARY_PARAMETER_OFFSET  = 51;

    private static final int DISCONNECT_TID      = 0x01;

	SYS___NEXUS_GET_OPT                = 508
	SYS___NEXUS_SET_OPT                = 509
	SYS___CHANNEL_OPEN                 = 510
	SYS___CHANNEL_GET_INFO             = 511
	SYS___CHANNEL_SYNC                 = 512
	SYS___CHANNEL_GET_OPT              = 513
	SYS___CHANNEL_SET_OPT              = 514
	SYS_ULOCK_WAIT                     = 515
	SYS_ULOCK_WAKE                     = 516
	SYS_FCLONEFILEAT                   = 517

			}
		})
	}
}

func TestOIDCAuthenticate(t *testing.T) {
	// Create a JWKS server
	rsaKey, err := rsa.GenerateKey(rand.Reader, 512)
	if err != nil {
		t.Fatalf("failed to generate a private key: %v", err)
	}
	key := jose.JSONWebKey{Algorithm: string(jose.RS256), Key: rsaKey}
	keySet := jose.JSONWebKeySet{}

    final S3ConnectionProperties s3ConnectionProperties = Mock()

    def setup(){
        _ * s3ConnectionProperties.getEndpoint() >> Optional.absent()
        _ * s3ConnectionProperties.getPartSize() >> 512
        _ * s3ConnectionProperties.getMultipartThreshold() >> 1024
    }

    def "Should upload to s3"() {
        given:
        AmazonS3Client amazonS3Client = Mock()

	rp.len = sp.len
	rp.cap = sp.len
	return
}

var (
	// printBacklog is a circular buffer of messages written with the builtin
	// print* functions, for use in postmortem analysis of core dumps.
	printBacklog      [512]byte
	printBacklogIndex int
)

// recordForPanic maintains a circular buffer of messages written by the
// runtime leading up to a process crash, allowing the messages to be
// extracted from a core dump.
//

				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
			}

			switch pType {
			case "heap":
				const javaHeapzSamplingRate = 524288 // 512K
				if s.Value[0] == 0 {
					return nil, nil, fmt.Errorf("parsing sample %s: second value must be non-zero", line)
				}
				s.NumLabel = map[string][]int64{"bytes": {s.Value[1] / s.Value[0]}}

00000110  90 99 5f 58 cb 3b 74                              |.._X.;t|
>>> Flow 2 (server to client)
00000000  16 03 03 00 7a 02 00 00  76 03 03 c2 2e 95 0c cf  |....z...v.......|
00000010  63 40 d8 a0 bd 51 27 e2  62 79 72 26 b1 d4 38 5b  |c@...Q'.byr&..8[|
00000020  50 03 66 d2 2e 8e 46 b7  cf 40 0a 20 00 00 00 00  |P.f...F..@. ....|
00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

        this.winsServer = Config.getInetAddressArray(p, "jcifs.netbios.wins", ",", new InetAddress[0]);

        this.transactionBufferSize = Config.getInt(p, "jcifs.smb.client.transaction_buf_size", 0xFFFF) - 512;
        this.bufferCacheSize = Config.getInt(p, "jcifs.smb.maxBuffers", 16);

        this.smbListSize = Config.getInt(p, "jcifs.smb.client.listSize", 65435);

			t.Errorf("#%d: incorrect plaintext: got %x, want %x", i, plaintext, test.out)
		}
	}
}

func TestNonZeroRandomBytes(t *testing.T) {
	random := rand.Reader

	b := make([]byte, 512)
	err := NonZeroRandomBytes(b, random)
	if err != nil {
		t.Errorf("returned error: %s", err)
	}
	for _, b := range b {
		if b == 0 {
			t.Errorf("Zero octet found")
			return
		}
	}
}