}
}

// Tests that blockGeneric (pure Go) and block (in assembly for some architectures) match.
func TestBlockGeneric(t *testing.T) {
	if boring.Enabled {
		t.Skip("BoringCrypto doesn't expose digest")
	}
	for i := 1; i < 30; i++ { // arbitrary factor
		gen, asm := New().(*digest), New().(*digest)
		buf := make([]byte, BlockSize*i)
		rand.Read(buf)
		blockGeneric(gen, buf)
		block(asm, buf)

	}
}

// Tests that blockGeneric (pure Go) and block (in assembly for some architectures) match.
func TestBlockGeneric(t *testing.T) {
	if boring.Enabled {
		t.Skip("BoringCrypto doesn't expose digest")
	}
	gen, asm := New().(*digest), New().(*digest)
	buf := make([]byte, BlockSize*20) // arbitrary factor
	rand.Read(buf)
	blockGeneric(gen, buf)
	block(asm, buf)
	if *gen != *asm {

	}
}

// Tests that blockGeneric (pure Go) and block (in assembly for some architectures) match.
func TestBlockGeneric(t *testing.T) {
	if boring.Enabled {
		t.Skip("BoringCrypto doesn't expose digest")
	}
	gen, asm := New().(*digest), New().(*digest)
	buf := make([]byte, BlockSize*20) // arbitrary factor
	rand.Read(buf)
	blockGeneric(gen, buf)
	block(asm, buf)
	if *gen != *asm {

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package chacha8rand

var Block = block
var Block_generic = block_generic

func Seed(s *State) [4]uint64 {
	return s.seed

	}

	Block(&seed, &b1, 4)
	Block_generic(&seed, &b2, 4)
	if !slices.Equal(b1[:], b2[:]) {
		var out bytes.Buffer
		fmt.Fprintf(&out, "%-18s %-18s\n", "block", "block_generic")
		for i := range b1 {
			suffix := ""
			if b1[i] != b2[i] {
				suffix = " mismatch!"
			}
			fmt.Fprintf(&out, "%#016x %#016x%s\n", b1[i], b2[i], suffix)
		}
		t.Errorf("block and block_generic disagree:\n%s", out.String())
	}
}

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

//go:build !amd64 && !arm64

#include "textflag.h"

// func block(counter uint64, seed *[8]uint32, blocks *[16][4]uint32)
TEXT ·block(SB), NOSPLIT, $0

}

func _() {
	// block and block_generic must have same type
	x := block
	x = block_generic
	_ = x
}

// block_generic is the non-assembly block implementation,
// for use on systems without special assembly.
// Even on such systems, it is quite fast: on GOOS=386,
// ChaCha8 using this code generates random values faster than PCG-DXSM.
func block_generic(seed *[4]uint64, buf *[32]uint64, counter uint32) {