<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="Encoding">
    <file url="file://$PROJECT_DIR$/libraries" charset="UTF-8" />
    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example" charset="UTF-8" />
    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library" charset="UTF-8" />
    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library/src/main/kotlin" charset="UTF-8" />

    apply {
      encodings[ 0x0] = encoding // Null character
      encodings[ 0x1] = encoding // Start of Header
      encodings[ 0x2] = encoding // Start of Text
      encodings[ 0x3] = encoding // End of Text
      encodings[ 0x4] = encoding // End of Transmission
      encodings[ 0x5] = encoding // Enquiry
      encodings[ 0x6] = encoding // Acknowledgment
      encodings[ 0x7] = encoding // Bell

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package noder

import "internal/pkgbits"

// A codeStmt distinguishes among statement encodings.
type codeStmt int

func (c codeStmt) Marker() pkgbits.SyncMarker { return pkgbits.SyncStmt1 }
func (c codeStmt) Value() int                 { return int(c) }

const (
	stmtEnd codeStmt = iota
	stmtLabel

	// Marker returns the SyncMarker for the Code's dynamic type.
	Marker() SyncMarker

	// Value returns the Code's ordinal value.
	Value() int
}

// A CodeVal distinguishes among go/constant.Value encodings.
type CodeVal int

func (c CodeVal) Marker() SyncMarker { return SyncVal }
func (c CodeVal) Value() int         { return int(c) }

// Note: These values are public and cannot be changed without

class JavaSerializationEncodingLookup {
    private
    val encodings = ConcurrentHashMap<Class<*>, EncodingDetails>()

    /**
     * Returns the proper encoding provider for the given type, or null, if not covered by Java Object serialization.
     */
    fun encodingFor(type: Class<*>): Encoding? {
        return encodings.computeIfAbsent(type) { t -> calculateEncoding(t) }.encoding
    }

    private

// license that can be found in the LICENSE file.

// Package encoding defines interfaces shared by other packages that
// convert data to and from byte-level and textual representations.
// Packages that check for these interfaces include encoding/gob,
// encoding/json, and encoding/xml. As a result, implementing an
// interface once can make a type useful in multiple encodings.

package ed25519_test

import (
	"crypto/ed25519"
	"encoding/hex"
	"encoding/json"
	"internal/testenv"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
)

// TestEd25519Vectors runs a very large set of test vectors that exercise all
// combinations of low-order points, low-order components, and non-canonical
// encodings. These vectors lock in unspecified and spec-divergent behaviors in

	//
	// For NIST curves, this decodes an uncompressed point according to SEC 1,
	// Version 2.0, Section 2.3.4. Compressed encodings and the point at
	// infinity are rejected.
	//
	// For X25519, this only checks the u-coordinate length. Adversarially
	// selected public keys can cause ECDH to return an error.
	NewPublicKey(key []byte) (*PublicKey, error)

	// ecdh performs an ECDH exchange and returns the shared secret. It's exposed

		}
	}
}

func TestWithoutPaddingClose(t *testing.T) {
	encodings := []*Encoding{
		StdEncoding,
		StdEncoding.WithPadding(NoPadding),
	}

	for _, encoding := range encodings {
		for _, testpair := range pairs {

			var buf strings.Builder
			encoder := NewEncoder(encoding, &buf)
			encoder.Write([]byte(testpair.decoded))
			encoder.Close()

  /*
   * Please do not add new Charset references to this class, unless those character encodings are
   * part of the set required to be supported by all Java platform implementations! Any Charsets
   * initialized here may cause unexpected delays when this class is loaded. See the Charset
   * Javadocs for the list of built-in character encodings.
   */