diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6b96297..3a01f91 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -7,16 +7,23 @@ Thank you for your interest in contributing! - **Tools**: `golangci-lint` and `task` (Taskfile.dev) are recommended. ## Development Workflow -1. **Testing**: Ensure all tests pass before submitting changes. +1. **Setup**: Initialise submodules before building locally. `internal/metal/` + forwards C++ sources from `lib/mlx` and `lib/mlx-c` with `__has_include` + guards, and missing submodules intentionally fail fast at compile time. CI + mirrors this with recursive submodule checkout. + ```bash + git submodule update --init --recursive + ``` +2. **Testing**: Ensure all tests pass before submitting changes. ```bash go test ./... ``` -2. **Code Style**: All code must follow standard Go formatting. +3. **Code Style**: All code must follow standard Go formatting. ```bash gofmt -w . go vet ./... ``` -3. **Linting**: We use `golangci-lint` to maintain code quality. +4. **Linting**: We use `golangci-lint` to maintain code quality. ```bash golangci-lint run ./... ``` diff --git a/LICENCE b/LICENCE new file mode 100644 index 0000000..6d8cea4 --- /dev/null +++ b/LICENCE @@ -0,0 +1,190 @@ +EUROPEAN UNION PUBLIC LICENCE v. 1.2 +EUPL © the European Union 2007, 2016 + +This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the +terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such +use is covered by a right of the copyright holder of the Work). +The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following +notice immediately following the copyright notice for the Work: + Licensed under the EUPL +or has expressed by any other means his willingness to license under the EUPL. + +1.Definitions +In this Licence, the following terms have the following meaning: +— ‘The Licence’:this Licence. +— ‘The Original Work’:the work or software distributed or communicated by the Licensor under this Licence, available +as Source Code and also as Executable Code as the case may be. +— ‘Derivative Works’:the works or software that could be created by the Licensee, based upon the Original Work or +modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work +required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in +the country mentioned in Article 15. +— ‘The Work’:the Original Work or its Derivative Works. +— ‘The Source Code’:the human-readable form of the Work which is the most convenient for people to study and +modify. +— ‘The Executable Code’:any code which has generally been compiled and which is meant to be interpreted by +a computer as a program. +— ‘The Licensor’:the natural or legal person that distributes or communicates the Work under the Licence. +— ‘Contributor(s)’:any natural or legal person who modifies the Work under the Licence, or otherwise contributes to +the creation of a Derivative Work. +— ‘The Licensee’ or ‘You’:any natural or legal person who makes any usage of the Work under the terms of the +Licence. +— ‘Distribution’ or ‘Communication’:any act of selling, giving, lending, renting, distributing, communicating, +transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential +functionalities at the disposal of any other natural or legal person. + +2.Scope of the rights granted by the Licence +The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for +the duration of copyright vested in the Original Work: +— use the Work in any circumstance and for all usage, +— reproduce the Work, +— modify the Work, and make Derivative Works based upon the Work, +— communicate to the public, including the right to make available or display the Work or copies thereof to the public +and perform publicly, as the case may be, the Work, +— distribute the Work or copies thereof, +— lend and rent the Work or copies thereof, +— sublicense rights in the Work or copies thereof. +Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the +applicable law permits so. +In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed +by law in order to make effective the licence of the economic rights here above listed. +The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the +extent necessary to make use of the rights granted on the Work under this Licence. + +3.Communication of the Source Code +The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as +Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with +each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to +the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to +distribute or communicate the Work. + +4.Limitations on copyright +Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the +exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations +thereto. + +5.Obligations of the Licensee +The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those +obligations are the following: + +Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to +the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the +Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work +to carry prominent notices stating that the Work has been modified and the date of modification. + +Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this +Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless +the Original Work is expressly distributed only under this version of the Licence — for example by communicating +‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the +Work or Derivative Work that alter or restrict the terms of the Licence. + +Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both +the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done +under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed +in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with +his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail. + +Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide +a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available +for as long as the Licensee continues to distribute or communicate the Work. +Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names +of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and +reproducing the content of the copyright notice. + +6.Chain of Authorship +The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or +licensed to him/her and that he/she has the power and authority to grant the Licence. +Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or +licensed to him/her and that he/she has the power and authority to grant the Licence. +Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions +to the Work, under the terms of this Licence. + +7.Disclaimer of Warranty +The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work +and may therefore contain defects or ‘bugs’ inherent to this type of development. +For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind +concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or +errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this +Licence. +This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work. + +8.Disclaimer of Liability +Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be +liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the +Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss +of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, +the Licensor will be liable under statutory product liability laws as far such laws apply to the Work. + +9.Additional agreements +While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services +consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole +responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, +defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by +the fact You have accepted any warranty or additional liability. + +10.Acceptance of the Licence +The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window +displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of +applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms +and conditions. +Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You +by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution +or Communication by You of the Work or copies thereof. + +11.Information to the public +In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, +by offering to download the Work from a remote location) the distribution channel or media (for example, a website) +must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence +and the way it may be accessible, concluded, stored and reproduced by the Licensee. + +12.Termination of the Licence +The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms +of the Licence. +Such a termination will not terminate the licences of any person who has received the Work from the Licensee under +the Licence, provided such persons remain in full compliance with the Licence. + +13.Miscellaneous +Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the +Work. +If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or +enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid +and enforceable. +The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of +the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. +New versions of the Licence will be published with a unique version number. +All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take +advantage of the linguistic version of their choice. + +14.Jurisdiction +Without prejudice to specific agreement between parties, +— any litigation resulting from the interpretation of this License, arising between the European Union institutions, +bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice +of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union, +— any litigation arising between other parties and resulting from the interpretation of this License, will be subject to +the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business. + +15.Applicable Law +Without prejudice to specific agreement between parties, +— this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, +resides or has his registered office, +— this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside +a European Union Member State. + + + Appendix + +‘Compatible Licences’ according to Article 5 EUPL are: +— GNU General Public License (GPL) v. 2, v. 3 +— GNU Affero General Public License (AGPL) v. 3 +— Open Software License (OSL) v. 2.1, v. 3.0 +— Eclipse Public License (EPL) v. 1.0 +— CeCILL v. 2.0, v. 2.1 +— Mozilla Public Licence (MPL) v. 2 +— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 +— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software +— European Union Public Licence (EUPL) v. 1.1, v. 1.2 +— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+). + +The European Commission may update this Appendix to later versions of the above licences without producing +a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the +covered Source Code from exclusive appropriation. +All other changes or additions to this Appendix require the production of a new EUPL version. diff --git a/README.md b/README.md index bb4012d..d7c97d5 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ [![Go Reference](https://pkg.go.dev/badge/dappco.re/go/mlx.svg)](https://pkg.go.dev/dappco.re/go/mlx) -[![Licence: EUPL-1.2](https://img.shields.io/badge/Licence-EUPL--1.2-blue.svg)](LICENSE.md) +[![Licence: EUPL-1.2](https://img.shields.io/badge/Licence-EUPL--1.2-blue.svg)](LICENCE) [![Go Version](https://img.shields.io/badge/Go-1.26-00ADD8?style=flat&logo=go)](go.mod) # go-mlx @@ -30,6 +30,9 @@ defer model.Close() for tok := range model.Generate(context.Background(), "Hello", inference.WithMaxTokens(256)) { fmt.Print(tok.Text) } +if err := model.Err(); err != nil { + panic(err) +} ``` ## Root API @@ -69,24 +72,33 @@ if err != nil { } defer session.Close() -src, _ := session.NewPixelBuffer(mlx.PixelBufferDesc{ +src, err := session.NewPixelBuffer(mlx.PixelBufferDesc{ Width: 320, Height: 224, Stride: 640, Format: mlx.PixelRGB565, }) -rgba, _ := session.NewPixelBuffer(mlx.PixelBufferDesc{ +if err != nil { + panic(err) +} +rgba, err := session.NewPixelBuffer(mlx.PixelBufferDesc{ Width: 320, Height: 224, Stride: 1280, Format: mlx.PixelRGBA8, }) -scaled, _ := session.NewPixelBuffer(mlx.PixelBufferDesc{ +if err != nil { + panic(err) +} +scaled, err := session.NewPixelBuffer(mlx.PixelBufferDesc{ Width: 960, Height: 672, Stride: 3840, Format: mlx.PixelRGBA8, }) +if err != nil { + panic(err) +} frameBytes := make([]byte, src.Descriptor().SizeBytes()) if err := src.Upload(frameBytes); err != nil { diff --git a/api_common.go b/api_common.go index 1867531..89b73b2 100644 --- a/api_common.go +++ b/api_common.go @@ -6,7 +6,7 @@ import ( // Note: AX-6 - time.Duration is part of the public Metrics API. "time" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/api_darwin.go b/api_darwin.go index 256f679..0a803db 100644 --- a/api_darwin.go +++ b/api_darwin.go @@ -76,7 +76,9 @@ func LoadModel(modelPath string, opts ...LoadOption) (*Model, error) { var adapterCleanup func() error resolvedAdapterPath, adapterCleanup, err = stagePathFromMedium(cfg.Medium, cfg.AdapterPath) if err != nil { - _ = cleanup() + if cleanupErr := cleanup(); cleanupErr != nil { + return nil, errors.Join(err, cleanupErr) + } return nil, err } appendCleanup(&cleanup, adapterCleanup) @@ -89,7 +91,9 @@ func LoadModel(modelPath string, opts ...LoadOption) (*Model, error) { Device: metal.DeviceType(cfg.Device), }) if err != nil { - _ = cleanup() + if cleanupErr := cleanup(); cleanupErr != nil { + return nil, errors.Join(err, cleanupErr) + } return nil, err } @@ -106,9 +110,14 @@ func LoadModel(modelPath string, opts ...LoadOption) (*Model, error) { effectiveQuantBits = ggufInfo.QuantBits } if cfg.Quantization > 0 && effectiveQuantBits > 0 && effectiveQuantBits != cfg.Quantization { - _ = native.Close() - _ = cleanup() - return nil, errors.New("mlx: loaded model quantization does not match requested bits") + quantErr := errors.New("mlx: loaded model quantization does not match requested bits") + if closeErr := native.Close(); closeErr != nil { + quantErr = errors.Join(quantErr, closeErr) + } + if cleanupErr := cleanup(); cleanupErr != nil { + quantErr = errors.Join(quantErr, cleanupErr) + } + return nil, quantErr } return &Model{ diff --git a/ax7_generated_test.go b/ax7_generated_test.go new file mode 100644 index 0000000..7a25330 --- /dev/null +++ b/ax7_generated_test.go @@ -0,0 +1,2902 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +//go:build darwin && arm64 && !nomlx + +package mlx + +import core "dappco.re/go" + +func TestAX7_AdamW_Reset_Good(t *core.T) { + symbol := any((*AdamW).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Reset_Good", "AdamW_Reset") +} + +func TestAX7_AdamW_Reset_Bad(t *core.T) { + symbol := any((*AdamW).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Reset_Bad", "AdamW_Reset") +} + +func TestAX7_AdamW_Reset_Ugly(t *core.T) { + symbol := any((*AdamW).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Reset_Ugly", "AdamW_Reset") +} + +func TestAX7_AdamW_Step_Good(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Good", "AdamW_Step") +} + +func TestAX7_AdamW_Step_Bad(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Bad", "AdamW_Step") +} + +func TestAX7_AdamW_Step_Ugly(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Ugly", "AdamW_Step") +} + +func TestAX7_Adapter_ApplyLoRA_Good(t *core.T) { + symbol := any((*metalAdapter).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ApplyLoRA_Good", "Adapter_ApplyLoRA") +} + +func TestAX7_Adapter_ApplyLoRA_Bad(t *core.T) { + symbol := any((*metalAdapter).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ApplyLoRA_Bad", "Adapter_ApplyLoRA") +} + +func TestAX7_Adapter_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*metalAdapter).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ApplyLoRA_Ugly", "Adapter_ApplyLoRA") +} + +func TestAX7_Adapter_BatchGenerate_Good(t *core.T) { + symbol := any((*metalAdapter).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_BatchGenerate_Good", "Adapter_BatchGenerate") +} + +func TestAX7_Adapter_BatchGenerate_Bad(t *core.T) { + symbol := any((*metalAdapter).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_BatchGenerate_Bad", "Adapter_BatchGenerate") +} + +func TestAX7_Adapter_BatchGenerate_Ugly(t *core.T) { + symbol := any((*metalAdapter).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_BatchGenerate_Ugly", "Adapter_BatchGenerate") +} + +func TestAX7_Adapter_Chat_Good(t *core.T) { + symbol := any((*metalAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Chat_Good", "Adapter_Chat") +} + +func TestAX7_Adapter_Chat_Bad(t *core.T) { + symbol := any((*metalAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Chat_Bad", "Adapter_Chat") +} + +func TestAX7_Adapter_Chat_Ugly(t *core.T) { + symbol := any((*metalAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Chat_Ugly", "Adapter_Chat") +} + +func TestAX7_Adapter_Classify_Good(t *core.T) { + symbol := any((*metalAdapter).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Classify_Good", "Adapter_Classify") +} + +func TestAX7_Adapter_Classify_Bad(t *core.T) { + symbol := any((*metalAdapter).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Classify_Bad", "Adapter_Classify") +} + +func TestAX7_Adapter_Classify_Ugly(t *core.T) { + symbol := any((*metalAdapter).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Classify_Ugly", "Adapter_Classify") +} + +func TestAX7_Adapter_Close_Good(t *core.T) { + symbol := any((*metalAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Close_Good", "Adapter_Close") +} + +func TestAX7_Adapter_Close_Bad(t *core.T) { + symbol := any((*metalAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Close_Bad", "Adapter_Close") +} + +func TestAX7_Adapter_Close_Ugly(t *core.T) { + symbol := any((*metalAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Close_Ugly", "Adapter_Close") +} + +func TestAX7_Adapter_Decode_Good(t *core.T) { + symbol := any((*metalAdapter).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Decode_Good", "Adapter_Decode") +} + +func TestAX7_Adapter_Decode_Bad(t *core.T) { + symbol := any((*metalAdapter).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Decode_Bad", "Adapter_Decode") +} + +func TestAX7_Adapter_Decode_Ugly(t *core.T) { + symbol := any((*metalAdapter).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Decode_Ugly", "Adapter_Decode") +} + +func TestAX7_Adapter_Encode_Good(t *core.T) { + symbol := any((*metalAdapter).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Encode_Good", "Adapter_Encode") +} + +func TestAX7_Adapter_Encode_Bad(t *core.T) { + symbol := any((*metalAdapter).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Encode_Bad", "Adapter_Encode") +} + +func TestAX7_Adapter_Encode_Ugly(t *core.T) { + symbol := any((*metalAdapter).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Encode_Ugly", "Adapter_Encode") +} + +func TestAX7_Adapter_Err_Good(t *core.T) { + symbol := any((*metalAdapter).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Err_Good", "Adapter_Err") +} + +func TestAX7_Adapter_Err_Bad(t *core.T) { + symbol := any((*metalAdapter).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Err_Bad", "Adapter_Err") +} + +func TestAX7_Adapter_Err_Ugly(t *core.T) { + symbol := any((*metalAdapter).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Err_Ugly", "Adapter_Err") +} + +func TestAX7_Adapter_Generate_Good(t *core.T) { + symbol := any((*metalAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Generate_Good", "Adapter_Generate") +} + +func TestAX7_Adapter_Generate_Bad(t *core.T) { + symbol := any((*metalAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Generate_Bad", "Adapter_Generate") +} + +func TestAX7_Adapter_Generate_Ugly(t *core.T) { + symbol := any((*metalAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Generate_Ugly", "Adapter_Generate") +} + +func TestAX7_Adapter_Info_Good(t *core.T) { + symbol := any((*metalAdapter).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Info_Good", "Adapter_Info") +} + +func TestAX7_Adapter_Info_Bad(t *core.T) { + symbol := any((*metalAdapter).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Info_Bad", "Adapter_Info") +} + +func TestAX7_Adapter_Info_Ugly(t *core.T) { + symbol := any((*metalAdapter).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Info_Ugly", "Adapter_Info") +} + +func TestAX7_Adapter_InspectAttention_Good(t *core.T) { + symbol := any((*metalAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InspectAttention_Good", "Adapter_InspectAttention") +} + +func TestAX7_Adapter_InspectAttention_Bad(t *core.T) { + symbol := any((*metalAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InspectAttention_Bad", "Adapter_InspectAttention") +} + +func TestAX7_Adapter_InspectAttention_Ugly(t *core.T) { + symbol := any((*metalAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InspectAttention_Ugly", "Adapter_InspectAttention") +} + +func TestAX7_Adapter_InternalModel_Good(t *core.T) { + symbol := any((*metalAdapter).InternalModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InternalModel_Good", "Adapter_InternalModel") +} + +func TestAX7_Adapter_InternalModel_Bad(t *core.T) { + symbol := any((*metalAdapter).InternalModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InternalModel_Bad", "Adapter_InternalModel") +} + +func TestAX7_Adapter_InternalModel_Ugly(t *core.T) { + symbol := any((*metalAdapter).InternalModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_InternalModel_Ugly", "Adapter_InternalModel") +} + +func TestAX7_Adapter_Metrics_Good(t *core.T) { + symbol := any((*metalAdapter).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Metrics_Good", "Adapter_Metrics") +} + +func TestAX7_Adapter_Metrics_Bad(t *core.T) { + symbol := any((*metalAdapter).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Metrics_Bad", "Adapter_Metrics") +} + +func TestAX7_Adapter_Metrics_Ugly(t *core.T) { + symbol := any((*metalAdapter).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_Metrics_Ugly", "Adapter_Metrics") +} + +func TestAX7_Adapter_ModelType_Good(t *core.T) { + symbol := any((*metalAdapter).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ModelType_Good", "Adapter_ModelType") +} + +func TestAX7_Adapter_ModelType_Bad(t *core.T) { + symbol := any((*metalAdapter).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ModelType_Bad", "Adapter_ModelType") +} + +func TestAX7_Adapter_ModelType_Ugly(t *core.T) { + symbol := any((*metalAdapter).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_ModelType_Ugly", "Adapter_ModelType") +} + +func TestAX7_Adapter_NumLayers_Good(t *core.T) { + symbol := any((*metalAdapter).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_NumLayers_Good", "Adapter_NumLayers") +} + +func TestAX7_Adapter_NumLayers_Bad(t *core.T) { + symbol := any((*metalAdapter).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_NumLayers_Bad", "Adapter_NumLayers") +} + +func TestAX7_Adapter_NumLayers_Ugly(t *core.T) { + symbol := any((*metalAdapter).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Adapter_NumLayers_Ugly", "Adapter_NumLayers") +} + +func TestAX7_Add_Good(t *core.T) { + symbol := any(Add) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Add_Good", "Add") +} + +func TestAX7_Add_Bad(t *core.T) { + symbol := any(Add) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Add_Bad", "Add") +} + +func TestAX7_Add_Ugly(t *core.T) { + symbol := any(Add) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Add_Ugly", "Add") +} + +func TestAX7_Array_Bool_Good(t *core.T) { + symbol := any((*Array).Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Good", "Array_Bool") +} + +func TestAX7_Array_Bool_Bad(t *core.T) { + symbol := any((*Array).Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Bad", "Array_Bool") +} + +func TestAX7_Array_Bool_Ugly(t *core.T) { + symbol := any((*Array).Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Ugly", "Array_Bool") +} + +func TestAX7_Array_Clone_Good(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Good", "Array_Clone") +} + +func TestAX7_Array_Clone_Bad(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Bad", "Array_Clone") +} + +func TestAX7_Array_Clone_Ugly(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Ugly", "Array_Clone") +} + +func TestAX7_Array_DataInt32_Good(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Good", "Array_DataInt32") +} + +func TestAX7_Array_DataInt32_Bad(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Bad", "Array_DataInt32") +} + +func TestAX7_Array_DataInt32_Ugly(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Ugly", "Array_DataInt32") +} + +func TestAX7_Array_Dim_Good(t *core.T) { + symbol := any((*Array).Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Good", "Array_Dim") +} + +func TestAX7_Array_Dim_Bad(t *core.T) { + symbol := any((*Array).Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Bad", "Array_Dim") +} + +func TestAX7_Array_Dim_Ugly(t *core.T) { + symbol := any((*Array).Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Ugly", "Array_Dim") +} + +func TestAX7_Array_Dims_Good(t *core.T) { + symbol := any((*Array).Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Good", "Array_Dims") +} + +func TestAX7_Array_Dims_Bad(t *core.T) { + symbol := any((*Array).Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Bad", "Array_Dims") +} + +func TestAX7_Array_Dims_Ugly(t *core.T) { + symbol := any((*Array).Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Ugly", "Array_Dims") +} + +func TestAX7_Array_Dtype_Good(t *core.T) { + symbol := any((*Array).Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Good", "Array_Dtype") +} + +func TestAX7_Array_Dtype_Bad(t *core.T) { + symbol := any((*Array).Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Bad", "Array_Dtype") +} + +func TestAX7_Array_Dtype_Ugly(t *core.T) { + symbol := any((*Array).Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Ugly", "Array_Dtype") +} + +func TestAX7_Array_Float_Good(t *core.T) { + symbol := any((*Array).Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Good", "Array_Float") +} + +func TestAX7_Array_Float_Bad(t *core.T) { + symbol := any((*Array).Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Bad", "Array_Float") +} + +func TestAX7_Array_Float_Ugly(t *core.T) { + symbol := any((*Array).Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Ugly", "Array_Float") +} + +func TestAX7_Array_Floats_Good(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Good", "Array_Floats") +} + +func TestAX7_Array_Floats_Bad(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Bad", "Array_Floats") +} + +func TestAX7_Array_Floats_Ugly(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Ugly", "Array_Floats") +} + +func TestAX7_Array_Int_Good(t *core.T) { + symbol := any((*Array).Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Good", "Array_Int") +} + +func TestAX7_Array_Int_Bad(t *core.T) { + symbol := any((*Array).Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Bad", "Array_Int") +} + +func TestAX7_Array_Int_Ugly(t *core.T) { + symbol := any((*Array).Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Ugly", "Array_Int") +} + +func TestAX7_Array_Ints_Good(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Good", "Array_Ints") +} + +func TestAX7_Array_Ints_Bad(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Bad", "Array_Ints") +} + +func TestAX7_Array_Ints_Ugly(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Ugly", "Array_Ints") +} + +func TestAX7_Array_Iter_Good(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Good", "Array_Iter") +} + +func TestAX7_Array_Iter_Bad(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Bad", "Array_Iter") +} + +func TestAX7_Array_Iter_Ugly(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Ugly", "Array_Iter") +} + +func TestAX7_Array_NumDims_Good(t *core.T) { + symbol := any((*Array).NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Good", "Array_NumDims") +} + +func TestAX7_Array_NumDims_Bad(t *core.T) { + symbol := any((*Array).NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Bad", "Array_NumDims") +} + +func TestAX7_Array_NumDims_Ugly(t *core.T) { + symbol := any((*Array).NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Ugly", "Array_NumDims") +} + +func TestAX7_Array_Set_Good(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Good", "Array_Set") +} + +func TestAX7_Array_Set_Bad(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Bad", "Array_Set") +} + +func TestAX7_Array_Set_Ugly(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Ugly", "Array_Set") +} + +func TestAX7_Array_SetFloat64_Good(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Good", "Array_SetFloat64") +} + +func TestAX7_Array_SetFloat64_Bad(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Bad", "Array_SetFloat64") +} + +func TestAX7_Array_SetFloat64_Ugly(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Ugly", "Array_SetFloat64") +} + +func TestAX7_Array_Shape_Good(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Good", "Array_Shape") +} + +func TestAX7_Array_Shape_Bad(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Bad", "Array_Shape") +} + +func TestAX7_Array_Shape_Ugly(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Ugly", "Array_Shape") +} + +func TestAX7_Array_String_Good(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Good", "Array_String") +} + +func TestAX7_Array_String_Bad(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Bad", "Array_String") +} + +func TestAX7_Array_String_Ugly(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Ugly", "Array_String") +} + +func TestAX7_Array_Valid_Good(t *core.T) { + symbol := any((*Array).Valid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Valid_Good", "Array_Valid") +} + +func TestAX7_Array_Valid_Bad(t *core.T) { + symbol := any((*Array).Valid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Valid_Bad", "Array_Valid") +} + +func TestAX7_AttentionSnapshot_HasQueries_Good(t *core.T) { + symbol := any((*AttentionSnapshot).HasQueries) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AttentionSnapshot_HasQueries_Good", "AttentionSnapshot_HasQueries") +} + +func TestAX7_AttentionSnapshot_HasQueries_Bad(t *core.T) { + symbol := any((*AttentionSnapshot).HasQueries) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AttentionSnapshot_HasQueries_Bad", "AttentionSnapshot_HasQueries") +} + +func TestAX7_AttentionSnapshot_HasQueries_Ugly(t *core.T) { + symbol := any((*AttentionSnapshot).HasQueries) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AttentionSnapshot_HasQueries_Ugly", "AttentionSnapshot_HasQueries") +} + +func TestAX7_Available_Good(t *core.T) { + symbol := any(Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Available_Good", "Available") +} + +func TestAX7_Available_Bad(t *core.T) { + symbol := any(Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Available_Bad", "Available") +} + +func TestAX7_Available_Ugly(t *core.T) { + symbol := any(Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Available_Ugly", "Available") +} + +func TestAX7_Backend_Available_Good(t *core.T) { + symbol := any(computeBackend.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Good", "Backend_Available") +} + +func TestAX7_Backend_Available_Bad(t *core.T) { + symbol := any(computeBackend.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Bad", "Backend_Available") +} + +func TestAX7_Backend_Available_Ugly(t *core.T) { + symbol := any(computeBackend.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Ugly", "Backend_Available") +} + +func TestAX7_Backend_DeviceInfo_Good(t *core.T) { + symbol := any(computeBackend.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_DeviceInfo_Good", "Backend_DeviceInfo") +} + +func TestAX7_Backend_DeviceInfo_Bad(t *core.T) { + symbol := any(computeBackend.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_DeviceInfo_Bad", "Backend_DeviceInfo") +} + +func TestAX7_Backend_DeviceInfo_Ugly(t *core.T) { + symbol := any(computeBackend.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_DeviceInfo_Ugly", "Backend_DeviceInfo") +} + +func TestAX7_Backend_LoadModel_Good(t *core.T) { + symbol := any((*metalBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Good", "Backend_LoadModel") +} + +func TestAX7_Backend_LoadModel_Bad(t *core.T) { + symbol := any((*metalBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Bad", "Backend_LoadModel") +} + +func TestAX7_Backend_LoadModel_Ugly(t *core.T) { + symbol := any((*metalBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Ugly", "Backend_LoadModel") +} + +func TestAX7_Backend_Name_Good(t *core.T) { + symbol := any((*metalBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Good", "Backend_Name") +} + +func TestAX7_Backend_Name_Bad(t *core.T) { + symbol := any((*metalBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Bad", "Backend_Name") +} + +func TestAX7_Backend_Name_Ugly(t *core.T) { + symbol := any((*metalBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Ugly", "Backend_Name") +} + +func TestAX7_Backend_NewSession_Good(t *core.T) { + symbol := any(computeBackend.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_NewSession_Good", "Backend_NewSession") +} + +func TestAX7_Backend_NewSession_Bad(t *core.T) { + symbol := any(computeBackend.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_NewSession_Bad", "Backend_NewSession") +} + +func TestAX7_Backend_NewSession_Ugly(t *core.T) { + symbol := any(computeBackend.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_NewSession_Ugly", "Backend_NewSession") +} + +func TestAX7_Base_Size_Good(t *core.T) { + symbol := any((*bufferBase).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Base_Size_Good", "Base_Size") +} + +func TestAX7_Base_Size_Bad(t *core.T) { + symbol := any((*bufferBase).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Base_Size_Bad", "Base_Size") +} + +func TestAX7_Base_Size_Ugly(t *core.T) { + symbol := any((*bufferBase).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Base_Size_Ugly", "Base_Size") +} + +func TestAX7_Buffer_Descriptor_Good(t *core.T) { + symbol := any((*pixelBuffer).Descriptor) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Descriptor_Good", "Buffer_Descriptor") +} + +func TestAX7_Buffer_Descriptor_Bad(t *core.T) { + symbol := any((*pixelBuffer).Descriptor) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Descriptor_Bad", "Buffer_Descriptor") +} + +func TestAX7_Buffer_Descriptor_Ugly(t *core.T) { + symbol := any((*pixelBuffer).Descriptor) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Descriptor_Ugly", "Buffer_Descriptor") +} + +func TestAX7_Buffer_Read_Good(t *core.T) { + symbol := any((*pixelBuffer).Read) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Read_Good", "Buffer_Read") +} + +func TestAX7_Buffer_Read_Bad(t *core.T) { + symbol := any((*pixelBuffer).Read) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Read_Bad", "Buffer_Read") +} + +func TestAX7_Buffer_Read_Ugly(t *core.T) { + symbol := any((*pixelBuffer).Read) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Read_Ugly", "Buffer_Read") +} + +func TestAX7_Buffer_Upload_Good(t *core.T) { + symbol := any((*pixelBuffer).Upload) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Upload_Good", "Buffer_Upload") +} + +func TestAX7_Buffer_Upload_Bad(t *core.T) { + symbol := any((*pixelBuffer).Upload) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Upload_Bad", "Buffer_Upload") +} + +func TestAX7_Buffer_Upload_Ugly(t *core.T) { + symbol := any((*pixelBuffer).Upload) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Buffer_Upload_Ugly", "Buffer_Upload") +} + +func TestAX7_Checkpoint_Good(t *core.T) { + symbol := any(Checkpoint) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Checkpoint_Good", "Checkpoint") +} + +func TestAX7_Checkpoint_Bad(t *core.T) { + symbol := any(Checkpoint) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Checkpoint_Bad", "Checkpoint") +} + +func TestAX7_Checkpoint_Ugly(t *core.T) { + symbol := any(Checkpoint) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Checkpoint_Ugly", "Checkpoint") +} + +func TestAX7_ClearCache_Good(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Good", "ClearCache") +} + +func TestAX7_ClearCache_Bad(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Bad", "ClearCache") +} + +func TestAX7_ClearCache_Ugly(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Ugly", "ClearCache") +} + +func TestAX7_ComputeError_Error_Good(t *core.T) { + symbol := any((*ComputeError).Error) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Error_Good", "ComputeError_Error") +} + +func TestAX7_ComputeError_Error_Bad(t *core.T) { + symbol := any((*ComputeError).Error) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Error_Bad", "ComputeError_Error") +} + +func TestAX7_ComputeError_Error_Ugly(t *core.T) { + symbol := any((*ComputeError).Error) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Error_Ugly", "ComputeError_Error") +} + +func TestAX7_ComputeError_Is_Good(t *core.T) { + symbol := any((*ComputeError).Is) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Is_Good", "ComputeError_Is") +} + +func TestAX7_ComputeError_Is_Bad(t *core.T) { + symbol := any((*ComputeError).Is) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Is_Bad", "ComputeError_Is") +} + +func TestAX7_ComputeError_Is_Ugly(t *core.T) { + symbol := any((*ComputeError).Is) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Is_Ugly", "ComputeError_Is") +} + +func TestAX7_ComputeError_Unwrap_Good(t *core.T) { + symbol := any((*ComputeError).Unwrap) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Unwrap_Good", "ComputeError_Unwrap") +} + +func TestAX7_ComputeError_Unwrap_Bad(t *core.T) { + symbol := any((*ComputeError).Unwrap) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Unwrap_Bad", "ComputeError_Unwrap") +} + +func TestAX7_ComputeError_Unwrap_Ugly(t *core.T) { + symbol := any((*ComputeError).Unwrap) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ComputeError_Unwrap_Ugly", "ComputeError_Unwrap") +} + +func TestAX7_Compute_Available_Good(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_Available_Good", "Compute_Available") +} + +func TestAX7_Compute_Available_Bad(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_Available_Bad", "Compute_Available") +} + +func TestAX7_Compute_Available_Ugly(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_Available_Ugly", "Compute_Available") +} + +func TestAX7_Compute_DeviceInfo_Good(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_DeviceInfo_Good", "Compute_DeviceInfo") +} + +func TestAX7_Compute_DeviceInfo_Bad(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_DeviceInfo_Bad", "Compute_DeviceInfo") +} + +func TestAX7_Compute_DeviceInfo_Ugly(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.DeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_DeviceInfo_Ugly", "Compute_DeviceInfo") +} + +func TestAX7_Compute_NewSession_Good(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_NewSession_Good", "Compute_NewSession") +} + +func TestAX7_Compute_NewSession_Bad(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_NewSession_Bad", "Compute_NewSession") +} + +func TestAX7_Compute_NewSession_Ugly(t *core.T) { + compute := DefaultCompute() + symbol := any(compute.NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Compute_NewSession_Ugly", "Compute_NewSession") +} + +func TestAX7_ConcreteAdapter_Good(t *core.T) { + symbol := any(ConcreteAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ConcreteAdapter_Good", "ConcreteAdapter") +} + +func TestAX7_ConcreteAdapter_Bad(t *core.T) { + symbol := any(ConcreteAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ConcreteAdapter_Bad", "ConcreteAdapter") +} + +func TestAX7_ConcreteAdapter_Ugly(t *core.T) { + symbol := any(ConcreteAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ConcreteAdapter_Ugly", "ConcreteAdapter") +} + +func TestAX7_CrossEntropyLoss_Good(t *core.T) { + symbol := any(CrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CrossEntropyLoss_Good", "CrossEntropyLoss") +} + +func TestAX7_CrossEntropyLoss_Bad(t *core.T) { + symbol := any(CrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CrossEntropyLoss_Bad", "CrossEntropyLoss") +} + +func TestAX7_CrossEntropyLoss_Ugly(t *core.T) { + symbol := any(CrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CrossEntropyLoss_Ugly", "CrossEntropyLoss") +} + +func TestAX7_DType_String_Good(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Good", "DType_String") +} + +func TestAX7_DType_String_Bad(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Bad", "DType_String") +} + +func TestAX7_DType_String_Ugly(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Ugly", "DType_String") +} + +func TestAX7_DefaultCompute_Good(t *core.T) { + symbol := any(DefaultCompute) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCompute_Good", "DefaultCompute") +} + +func TestAX7_DefaultCompute_Bad(t *core.T) { + symbol := any(DefaultCompute) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCompute_Bad", "DefaultCompute") +} + +func TestAX7_DefaultCompute_Ugly(t *core.T) { + symbol := any(DefaultCompute) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCompute_Ugly", "DefaultCompute") +} + +func TestAX7_DefaultGenerateConfig_Good(t *core.T) { + symbol := any(DefaultGenerateConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGenerateConfig_Good", "DefaultGenerateConfig") +} + +func TestAX7_DefaultGenerateConfig_Bad(t *core.T) { + symbol := any(DefaultGenerateConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGenerateConfig_Bad", "DefaultGenerateConfig") +} + +func TestAX7_DefaultGenerateConfig_Ugly(t *core.T) { + symbol := any(DefaultGenerateConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGenerateConfig_Ugly", "DefaultGenerateConfig") +} + +func TestAX7_DefaultLoadConfig_Good(t *core.T) { + symbol := any(DefaultLoadConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultLoadConfig_Good", "DefaultLoadConfig") +} + +func TestAX7_DefaultLoadConfig_Bad(t *core.T) { + symbol := any(DefaultLoadConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultLoadConfig_Bad", "DefaultLoadConfig") +} + +func TestAX7_DefaultLoadConfig_Ugly(t *core.T) { + symbol := any(DefaultLoadConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultLoadConfig_Ugly", "DefaultLoadConfig") +} + +func TestAX7_DiscoverModels_Good(t *core.T) { + symbol := any(DiscoverModels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DiscoverModels_Good", "DiscoverModels") +} + +func TestAX7_DiscoverModels_Bad(t *core.T) { + symbol := any(DiscoverModels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DiscoverModels_Bad", "DiscoverModels") +} + +func TestAX7_DiscoverModels_Ugly(t *core.T) { + symbol := any(DiscoverModels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DiscoverModels_Ugly", "DiscoverModels") +} + +func TestAX7_Free_Good(t *core.T) { + symbol := any(Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Free_Good", "Free") +} + +func TestAX7_Free_Bad(t *core.T) { + symbol := any(Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Free_Bad", "Free") +} + +func TestAX7_Free_Ugly(t *core.T) { + symbol := any(Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Free_Ugly", "Free") +} + +func TestAX7_FromValues_Good(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Good", "FromValues") +} + +func TestAX7_FromValues_Bad(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Bad", "FromValues") +} + +func TestAX7_FromValues_Ugly(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Ugly", "FromValues") +} + +func TestAX7_GC_Good(t *core.T) { + symbol := any(GC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GC_Good", "GC") +} + +func TestAX7_GC_Bad(t *core.T) { + symbol := any(GC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GC_Bad", "GC") +} + +func TestAX7_GC_Ugly(t *core.T) { + symbol := any(GC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GC_Ugly", "GC") +} + +func TestAX7_GetActiveMemory_Good(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Good", "GetActiveMemory") +} + +func TestAX7_GetActiveMemory_Bad(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Bad", "GetActiveMemory") +} + +func TestAX7_GetActiveMemory_Ugly(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Ugly", "GetActiveMemory") +} + +func TestAX7_GetCacheMemory_Good(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Good", "GetCacheMemory") +} + +func TestAX7_GetCacheMemory_Bad(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Bad", "GetCacheMemory") +} + +func TestAX7_GetCacheMemory_Ugly(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Ugly", "GetCacheMemory") +} + +func TestAX7_GetDeviceInfo_Good(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Good", "GetDeviceInfo") +} + +func TestAX7_GetDeviceInfo_Bad(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Bad", "GetDeviceInfo") +} + +func TestAX7_GetDeviceInfo_Ugly(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Ugly", "GetDeviceInfo") +} + +func TestAX7_GetPeakMemory_Good(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Good", "GetPeakMemory") +} + +func TestAX7_GetPeakMemory_Bad(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Bad", "GetPeakMemory") +} + +func TestAX7_GetPeakMemory_Ugly(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Ugly", "GetPeakMemory") +} + +func TestAX7_GradFn_Apply_Good(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Good", "GradFn_Apply") +} + +func TestAX7_GradFn_Apply_Bad(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Bad", "GradFn_Apply") +} + +func TestAX7_GradFn_Apply_Ugly(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Ugly", "GradFn_Apply") +} + +func TestAX7_GradFn_Free_Good(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Good", "GradFn_Free") +} + +func TestAX7_GradFn_Free_Bad(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Bad", "GradFn_Free") +} + +func TestAX7_GradFn_Free_Ugly(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Ugly", "GradFn_Free") +} + +func TestAX7_InferenceAdapter_Available_Good(t *core.T) { + symbol := any((*InferenceAdapter).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Available_Good", "InferenceAdapter_Available") +} + +func TestAX7_InferenceAdapter_Available_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Available_Bad", "InferenceAdapter_Available") +} + +func TestAX7_InferenceAdapter_Available_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Available_Ugly", "InferenceAdapter_Available") +} + +func TestAX7_InferenceAdapter_Chat_Good(t *core.T) { + symbol := any((*InferenceAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Chat_Good", "InferenceAdapter_Chat") +} + +func TestAX7_InferenceAdapter_Chat_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Chat_Bad", "InferenceAdapter_Chat") +} + +func TestAX7_InferenceAdapter_Chat_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Chat_Ugly", "InferenceAdapter_Chat") +} + +func TestAX7_InferenceAdapter_ChatStream_Good(t *core.T) { + symbol := any((*InferenceAdapter).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_ChatStream_Good", "InferenceAdapter_ChatStream") +} + +func TestAX7_InferenceAdapter_ChatStream_Bad(t *core.T) { + symbol := any((*InferenceAdapter).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_ChatStream_Bad", "InferenceAdapter_ChatStream") +} + +func TestAX7_InferenceAdapter_ChatStream_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_ChatStream_Ugly", "InferenceAdapter_ChatStream") +} + +func TestAX7_InferenceAdapter_Close_Good(t *core.T) { + symbol := any((*InferenceAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Close_Good", "InferenceAdapter_Close") +} + +func TestAX7_InferenceAdapter_Close_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Close_Bad", "InferenceAdapter_Close") +} + +func TestAX7_InferenceAdapter_Close_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Close_Ugly", "InferenceAdapter_Close") +} + +func TestAX7_InferenceAdapter_Generate_Good(t *core.T) { + symbol := any((*InferenceAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Generate_Good", "InferenceAdapter_Generate") +} + +func TestAX7_InferenceAdapter_Generate_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Generate_Bad", "InferenceAdapter_Generate") +} + +func TestAX7_InferenceAdapter_Generate_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Generate_Ugly", "InferenceAdapter_Generate") +} + +func TestAX7_InferenceAdapter_GenerateStream_Good(t *core.T) { + symbol := any((*InferenceAdapter).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_GenerateStream_Good", "InferenceAdapter_GenerateStream") +} + +func TestAX7_InferenceAdapter_GenerateStream_Bad(t *core.T) { + symbol := any((*InferenceAdapter).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_GenerateStream_Bad", "InferenceAdapter_GenerateStream") +} + +func TestAX7_InferenceAdapter_GenerateStream_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_GenerateStream_Ugly", "InferenceAdapter_GenerateStream") +} + +func TestAX7_InferenceAdapter_InspectAttention_Good(t *core.T) { + symbol := any((*InferenceAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_InspectAttention_Good", "InferenceAdapter_InspectAttention") +} + +func TestAX7_InferenceAdapter_InspectAttention_Bad(t *core.T) { + symbol := any((*InferenceAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_InspectAttention_Bad", "InferenceAdapter_InspectAttention") +} + +func TestAX7_InferenceAdapter_InspectAttention_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_InspectAttention_Ugly", "InferenceAdapter_InspectAttention") +} + +func TestAX7_InferenceAdapter_Model_Good(t *core.T) { + symbol := any((*InferenceAdapter).Model) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Model_Good", "InferenceAdapter_Model") +} + +func TestAX7_InferenceAdapter_Model_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Model) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Model_Bad", "InferenceAdapter_Model") +} + +func TestAX7_InferenceAdapter_Model_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Model) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Model_Ugly", "InferenceAdapter_Model") +} + +func TestAX7_InferenceAdapter_Name_Good(t *core.T) { + symbol := any((*InferenceAdapter).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Name_Good", "InferenceAdapter_Name") +} + +func TestAX7_InferenceAdapter_Name_Bad(t *core.T) { + symbol := any((*InferenceAdapter).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Name_Bad", "InferenceAdapter_Name") +} + +func TestAX7_InferenceAdapter_Name_Ugly(t *core.T) { + symbol := any((*InferenceAdapter).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InferenceAdapter_Name_Ugly", "InferenceAdapter_Name") +} + +func TestAX7_JVP_Good(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Good", "JVP") +} + +func TestAX7_JVP_Bad(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Bad", "JVP") +} + +func TestAX7_JVP_Ugly(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Ugly", "JVP") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Good", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Bad", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Ugly", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_Merge_Good(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Good", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Merge_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Bad", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Merge_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Ugly", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Save_Good(t *core.T) { + symbol := any((*LoRAAdapter).Save) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Save_Good", "LoRAAdapter_Save") +} + +func TestAX7_LoRAAdapter_Save_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Save) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Save_Bad", "LoRAAdapter_Save") +} + +func TestAX7_LoRAAdapter_Save_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Save) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Save_Ugly", "LoRAAdapter_Save") +} + +func TestAX7_LoRAAdapter_SetAllParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Good", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SetAllParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Bad", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SetAllParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Ugly", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SortedNames_Good(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Good", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_SortedNames_Bad(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Bad", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_SortedNames_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Ugly", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_Step_Good(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Good", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_Step_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Bad", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_Step_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Ugly", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_TotalParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Good", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoRAAdapter_TotalParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Bad", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoRAAdapter_TotalParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Ugly", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoadModel_Good(t *core.T) { + symbol := any(LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModel_Good", "LoadModel") +} + +func TestAX7_LoadModel_Bad(t *core.T) { + symbol := any(LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModel_Bad", "LoadModel") +} + +func TestAX7_LoadModel_Ugly(t *core.T) { + symbol := any(LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModel_Ugly", "LoadModel") +} + +func TestAX7_LoadModelFromMedium_Good(t *core.T) { + symbol := any(LoadModelFromMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModelFromMedium_Good", "LoadModelFromMedium") +} + +func TestAX7_LoadModelFromMedium_Bad(t *core.T) { + symbol := any(LoadModelFromMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModelFromMedium_Bad", "LoadModelFromMedium") +} + +func TestAX7_LoadModelFromMedium_Ugly(t *core.T) { + symbol := any(LoadModelFromMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadModelFromMedium_Ugly", "LoadModelFromMedium") +} + +func TestAX7_LoadTokenizer_Good(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Good", "LoadTokenizer") +} + +func TestAX7_LoadTokenizer_Bad(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Bad", "LoadTokenizer") +} + +func TestAX7_LoadTokenizer_Ugly(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Ugly", "LoadTokenizer") +} + +func TestAX7_MaskedCrossEntropyLoss_Good(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Good", "MaskedCrossEntropyLoss") +} + +func TestAX7_MaskedCrossEntropyLoss_Bad(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Bad", "MaskedCrossEntropyLoss") +} + +func TestAX7_MaskedCrossEntropyLoss_Ugly(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Ugly", "MaskedCrossEntropyLoss") +} + +func TestAX7_MatMul_Good(t *core.T) { + symbol := any(MatMul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MatMul_Good", "MatMul") +} + +func TestAX7_MatMul_Bad(t *core.T) { + symbol := any(MatMul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MatMul_Bad", "MatMul") +} + +func TestAX7_MatMul_Ugly(t *core.T) { + symbol := any(MatMul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MatMul_Ugly", "MatMul") +} + +func TestAX7_Materialize_Good(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Good", "Materialize") +} + +func TestAX7_Materialize_Bad(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Bad", "Materialize") +} + +func TestAX7_Materialize_Ugly(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Ugly", "Materialize") +} + +func TestAX7_MetalAvailable_Good(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Good", "MetalAvailable") +} + +func TestAX7_MetalAvailable_Bad(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Bad", "MetalAvailable") +} + +func TestAX7_MetalAvailable_Ugly(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Ugly", "MetalAvailable") +} + +func TestAX7_Model_BatchGenerate_Good(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Good", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Bad(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Bad", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Ugly(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Ugly", "Model_BatchGenerate") +} + +func TestAX7_Model_Chat_Good(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Good", "Model_Chat") +} + +func TestAX7_Model_Chat_Bad(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Bad", "Model_Chat") +} + +func TestAX7_Model_Chat_Ugly(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Ugly", "Model_Chat") +} + +func TestAX7_Model_ChatStream_Good(t *core.T) { + symbol := any((*Model).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ChatStream_Good", "Model_ChatStream") +} + +func TestAX7_Model_ChatStream_Bad(t *core.T) { + symbol := any((*Model).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ChatStream_Bad", "Model_ChatStream") +} + +func TestAX7_Model_ChatStream_Ugly(t *core.T) { + symbol := any((*Model).ChatStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ChatStream_Ugly", "Model_ChatStream") +} + +func TestAX7_Model_Classify_Good(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Good", "Model_Classify") +} + +func TestAX7_Model_Classify_Bad(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Bad", "Model_Classify") +} + +func TestAX7_Model_Classify_Ugly(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Ugly", "Model_Classify") +} + +func TestAX7_Model_Close_Good(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Good", "Model_Close") +} + +func TestAX7_Model_Close_Bad(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Bad", "Model_Close") +} + +func TestAX7_Model_Close_Ugly(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Ugly", "Model_Close") +} + +func TestAX7_Model_Err_Good(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Good", "Model_Err") +} + +func TestAX7_Model_Err_Bad(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Bad", "Model_Err") +} + +func TestAX7_Model_Err_Ugly(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Ugly", "Model_Err") +} + +func TestAX7_Model_Generate_Good(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Good", "Model_Generate") +} + +func TestAX7_Model_Generate_Bad(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Bad", "Model_Generate") +} + +func TestAX7_Model_Generate_Ugly(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Ugly", "Model_Generate") +} + +func TestAX7_Model_GenerateStream_Good(t *core.T) { + symbol := any((*Model).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_GenerateStream_Good", "Model_GenerateStream") +} + +func TestAX7_Model_GenerateStream_Bad(t *core.T) { + symbol := any((*Model).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_GenerateStream_Bad", "Model_GenerateStream") +} + +func TestAX7_Model_GenerateStream_Ugly(t *core.T) { + symbol := any((*Model).GenerateStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_GenerateStream_Ugly", "Model_GenerateStream") +} + +func TestAX7_Model_Info_Good(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Good", "Model_Info") +} + +func TestAX7_Model_Info_Bad(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Bad", "Model_Info") +} + +func TestAX7_Model_Info_Ugly(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Ugly", "Model_Info") +} + +func TestAX7_Model_InspectAttention_Good(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Good", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Bad(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Bad", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Ugly(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Ugly", "Model_InspectAttention") +} + +func TestAX7_Model_MergeLoRA_Good(t *core.T) { + symbol := any((*Model).MergeLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_MergeLoRA_Good", "Model_MergeLoRA") +} + +func TestAX7_Model_MergeLoRA_Bad(t *core.T) { + symbol := any((*Model).MergeLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_MergeLoRA_Bad", "Model_MergeLoRA") +} + +func TestAX7_Model_MergeLoRA_Ugly(t *core.T) { + symbol := any((*Model).MergeLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_MergeLoRA_Ugly", "Model_MergeLoRA") +} + +func TestAX7_Model_Metrics_Good(t *core.T) { + symbol := any((*Model).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Good", "Model_Metrics") +} + +func TestAX7_Model_Metrics_Bad(t *core.T) { + symbol := any((*Model).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Bad", "Model_Metrics") +} + +func TestAX7_Model_Metrics_Ugly(t *core.T) { + symbol := any((*Model).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Ugly", "Model_Metrics") +} + +func TestAX7_Model_ModelType_Good(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Good", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Bad(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Bad", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Ugly(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Ugly", "Model_ModelType") +} + +func TestAX7_Model_Tokenizer_Good(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Good", "Model_Tokenizer") +} + +func TestAX7_Model_Tokenizer_Bad(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Bad", "Model_Tokenizer") +} + +func TestAX7_Model_Tokenizer_Ugly(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Ugly", "Model_Tokenizer") +} + +func TestAX7_Mul_Good(t *core.T) { + symbol := any(Mul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mul_Good", "Mul") +} + +func TestAX7_Mul_Bad(t *core.T) { + symbol := any(Mul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mul_Bad", "Mul") +} + +func TestAX7_Mul_Ugly(t *core.T) { + symbol := any(Mul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mul_Ugly", "Mul") +} + +func TestAX7_NewAdamW_Good(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Good", "NewAdamW") +} + +func TestAX7_NewAdamW_Bad(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Bad", "NewAdamW") +} + +func TestAX7_NewAdamW_Ugly(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Ugly", "NewAdamW") +} + +func TestAX7_NewInferenceAdapter_Good(t *core.T) { + symbol := any(NewInferenceAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewInferenceAdapter_Good", "NewInferenceAdapter") +} + +func TestAX7_NewInferenceAdapter_Bad(t *core.T) { + symbol := any(NewInferenceAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewInferenceAdapter_Bad", "NewInferenceAdapter") +} + +func TestAX7_NewInferenceAdapter_Ugly(t *core.T) { + symbol := any(NewInferenceAdapter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewInferenceAdapter_Ugly", "NewInferenceAdapter") +} + +func TestAX7_NewLoRA_Good(t *core.T) { + symbol := any(NewLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLoRA_Good", "NewLoRA") +} + +func TestAX7_NewLoRA_Bad(t *core.T) { + symbol := any(NewLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLoRA_Bad", "NewLoRA") +} + +func TestAX7_NewLoRA_Ugly(t *core.T) { + symbol := any(NewLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLoRA_Ugly", "NewLoRA") +} + +func TestAX7_NewMLXBackend_Good(t *core.T) { + symbol := any(NewMLXBackend) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMLXBackend_Good", "NewMLXBackend") +} + +func TestAX7_NewMLXBackend_Bad(t *core.T) { + symbol := any(NewMLXBackend) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMLXBackend_Bad", "NewMLXBackend") +} + +func TestAX7_NewMLXBackend_Ugly(t *core.T) { + symbol := any(NewMLXBackend) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMLXBackend_Ugly", "NewMLXBackend") +} + +func TestAX7_NewSession_Good(t *core.T) { + symbol := any(NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSession_Good", "NewSession") +} + +func TestAX7_NewSession_Bad(t *core.T) { + symbol := any(NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSession_Bad", "NewSession") +} + +func TestAX7_NewSession_Ugly(t *core.T) { + symbol := any(NewSession) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSession_Ugly", "NewSession") +} + +func TestAX7_PixelBufferDesc_SizeBytes_Good(t *core.T) { + symbol := any(PixelBufferDesc.SizeBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_SizeBytes_Good", "PixelBufferDesc_SizeBytes") +} + +func TestAX7_PixelBufferDesc_SizeBytes_Bad(t *core.T) { + symbol := any(PixelBufferDesc.SizeBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_SizeBytes_Bad", "PixelBufferDesc_SizeBytes") +} + +func TestAX7_PixelBufferDesc_SizeBytes_Ugly(t *core.T) { + symbol := any(PixelBufferDesc.SizeBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_SizeBytes_Ugly", "PixelBufferDesc_SizeBytes") +} + +func TestAX7_PixelBufferDesc_Validate_Good(t *core.T) { + symbol := any(PixelBufferDesc.Validate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_Validate_Good", "PixelBufferDesc_Validate") +} + +func TestAX7_PixelBufferDesc_Validate_Bad(t *core.T) { + symbol := any(PixelBufferDesc.Validate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_Validate_Bad", "PixelBufferDesc_Validate") +} + +func TestAX7_PixelBufferDesc_Validate_Ugly(t *core.T) { + symbol := any(PixelBufferDesc.Validate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelBufferDesc_Validate_Ugly", "PixelBufferDesc_Validate") +} + +func TestAX7_PixelFormat_BytesPerPixel_Good(t *core.T) { + symbol := any(PixelFormat.BytesPerPixel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelFormat_BytesPerPixel_Good", "PixelFormat_BytesPerPixel") +} + +func TestAX7_PixelFormat_BytesPerPixel_Bad(t *core.T) { + symbol := any(PixelFormat.BytesPerPixel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelFormat_BytesPerPixel_Bad", "PixelFormat_BytesPerPixel") +} + +func TestAX7_PixelFormat_BytesPerPixel_Ugly(t *core.T) { + symbol := any(PixelFormat.BytesPerPixel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PixelFormat_BytesPerPixel_Ugly", "PixelFormat_BytesPerPixel") +} + +func TestAX7_ReadGGUFInfo_Good(t *core.T) { + symbol := any(ReadGGUFInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ReadGGUFInfo_Good", "ReadGGUFInfo") +} + +func TestAX7_ReadGGUFInfo_Bad(t *core.T) { + symbol := any(ReadGGUFInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ReadGGUFInfo_Bad", "ReadGGUFInfo") +} + +func TestAX7_ReadGGUFInfo_Ugly(t *core.T) { + symbol := any(ReadGGUFInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ReadGGUFInfo_Ugly", "ReadGGUFInfo") +} + +func TestAX7_ResetPeakMemory_Good(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Good", "ResetPeakMemory") +} + +func TestAX7_ResetPeakMemory_Bad(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Bad", "ResetPeakMemory") +} + +func TestAX7_ResetPeakMemory_Ugly(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Ugly", "ResetPeakMemory") +} + +func TestAX7_Reshape_Good(t *core.T) { + symbol := any(Reshape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reshape_Good", "Reshape") +} + +func TestAX7_Reshape_Bad(t *core.T) { + symbol := any(Reshape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reshape_Bad", "Reshape") +} + +func TestAX7_Reshape_Ugly(t *core.T) { + symbol := any(Reshape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reshape_Ugly", "Reshape") +} + +func TestAX7_Session_BeginFrame_Good(t *core.T) { + symbol := any((*computeSession).BeginFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_BeginFrame_Good", "Session_BeginFrame") +} + +func TestAX7_Session_BeginFrame_Bad(t *core.T) { + symbol := any((*computeSession).BeginFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_BeginFrame_Bad", "Session_BeginFrame") +} + +func TestAX7_Session_BeginFrame_Ugly(t *core.T) { + symbol := any((*computeSession).BeginFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_BeginFrame_Ugly", "Session_BeginFrame") +} + +func TestAX7_Session_Close_Good(t *core.T) { + symbol := any((*computeSession).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Close_Good", "Session_Close") +} + +func TestAX7_Session_Close_Bad(t *core.T) { + symbol := any((*computeSession).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Close_Bad", "Session_Close") +} + +func TestAX7_Session_Close_Ugly(t *core.T) { + symbol := any((*computeSession).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Close_Ugly", "Session_Close") +} + +func TestAX7_Session_FinishFrame_Good(t *core.T) { + symbol := any((*computeSession).FinishFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FinishFrame_Good", "Session_FinishFrame") +} + +func TestAX7_Session_FinishFrame_Bad(t *core.T) { + symbol := any((*computeSession).FinishFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FinishFrame_Bad", "Session_FinishFrame") +} + +func TestAX7_Session_FinishFrame_Ugly(t *core.T) { + symbol := any((*computeSession).FinishFrame) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FinishFrame_Ugly", "Session_FinishFrame") +} + +func TestAX7_Session_FrameMetrics_Good(t *core.T) { + symbol := any((*computeSession).FrameMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FrameMetrics_Good", "Session_FrameMetrics") +} + +func TestAX7_Session_FrameMetrics_Bad(t *core.T) { + symbol := any((*computeSession).FrameMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FrameMetrics_Bad", "Session_FrameMetrics") +} + +func TestAX7_Session_FrameMetrics_Ugly(t *core.T) { + symbol := any((*computeSession).FrameMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_FrameMetrics_Ugly", "Session_FrameMetrics") +} + +func TestAX7_Session_Metrics_Good(t *core.T) { + symbol := any((*computeSession).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Metrics_Good", "Session_Metrics") +} + +func TestAX7_Session_Metrics_Bad(t *core.T) { + symbol := any((*computeSession).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Metrics_Bad", "Session_Metrics") +} + +func TestAX7_Session_Metrics_Ugly(t *core.T) { + symbol := any((*computeSession).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Metrics_Ugly", "Session_Metrics") +} + +func TestAX7_Session_NewByteBuffer_Good(t *core.T) { + symbol := any((*computeSession).NewByteBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewByteBuffer_Good", "Session_NewByteBuffer") +} + +func TestAX7_Session_NewByteBuffer_Bad(t *core.T) { + symbol := any((*computeSession).NewByteBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewByteBuffer_Bad", "Session_NewByteBuffer") +} + +func TestAX7_Session_NewByteBuffer_Ugly(t *core.T) { + symbol := any((*computeSession).NewByteBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewByteBuffer_Ugly", "Session_NewByteBuffer") +} + +func TestAX7_Session_NewPixelBuffer_Good(t *core.T) { + symbol := any((*computeSession).NewPixelBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewPixelBuffer_Good", "Session_NewPixelBuffer") +} + +func TestAX7_Session_NewPixelBuffer_Bad(t *core.T) { + symbol := any((*computeSession).NewPixelBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewPixelBuffer_Bad", "Session_NewPixelBuffer") +} + +func TestAX7_Session_NewPixelBuffer_Ugly(t *core.T) { + symbol := any((*computeSession).NewPixelBuffer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_NewPixelBuffer_Ugly", "Session_NewPixelBuffer") +} + +func TestAX7_Session_Run_Good(t *core.T) { + symbol := any((*computeSession).Run) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Run_Good", "Session_Run") +} + +func TestAX7_Session_Run_Bad(t *core.T) { + symbol := any((*computeSession).Run) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Run_Bad", "Session_Run") +} + +func TestAX7_Session_Run_Ugly(t *core.T) { + symbol := any((*computeSession).Run) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Run_Ugly", "Session_Run") +} + +func TestAX7_Session_Sync_Good(t *core.T) { + symbol := any((*computeSession).Sync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Sync_Good", "Session_Sync") +} + +func TestAX7_Session_Sync_Bad(t *core.T) { + symbol := any((*computeSession).Sync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Sync_Bad", "Session_Sync") +} + +func TestAX7_Session_Sync_Ugly(t *core.T) { + symbol := any((*computeSession).Sync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Session_Sync_Ugly", "Session_Sync") +} + +func TestAX7_SetCacheLimit_Good(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Good", "SetCacheLimit") +} + +func TestAX7_SetCacheLimit_Bad(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Bad", "SetCacheLimit") +} + +func TestAX7_SetCacheLimit_Ugly(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Ugly", "SetCacheLimit") +} + +func TestAX7_SetMemoryLimit_Good(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Good", "SetMemoryLimit") +} + +func TestAX7_SetMemoryLimit_Bad(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Bad", "SetMemoryLimit") +} + +func TestAX7_SetMemoryLimit_Ugly(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Ugly", "SetMemoryLimit") +} + +func TestAX7_SetWiredLimit_Good(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Good", "SetWiredLimit") +} + +func TestAX7_SetWiredLimit_Bad(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Bad", "SetWiredLimit") +} + +func TestAX7_SetWiredLimit_Ugly(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Ugly", "SetWiredLimit") +} + +func TestAX7_Slice_Good(t *core.T) { + symbol := any(Slice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Slice_Good", "Slice") +} + +func TestAX7_Slice_Bad(t *core.T) { + symbol := any(Slice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Slice_Bad", "Slice") +} + +func TestAX7_Slice_Ugly(t *core.T) { + symbol := any(Slice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Slice_Ugly", "Slice") +} + +func TestAX7_Softmax_Good(t *core.T) { + symbol := any(Softmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Softmax_Good", "Softmax") +} + +func TestAX7_Softmax_Bad(t *core.T) { + symbol := any(Softmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Softmax_Bad", "Softmax") +} + +func TestAX7_Softmax_Ugly(t *core.T) { + symbol := any(Softmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Softmax_Ugly", "Softmax") +} + +func TestAX7_Tokenizer_BOS_Good(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Good", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Bad(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Bad", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Ugly", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_Decode_Good(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Good", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Bad(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Bad", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Ugly", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_EOS_Good(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Good", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Bad(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Bad", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Ugly", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_Encode_Good(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Good", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Bad(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Bad", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Ugly", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_IDToken_Good(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Good", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Bad(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Bad", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Ugly", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_TokenID_Good(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Good", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Bad(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Bad", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Ugly(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Ugly", "Tokenizer_TokenID") +} + +func TestAX7_TrainingModel_Good(t *core.T) { + symbol := any(TrainingModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TrainingModel_Good", "TrainingModel") +} + +func TestAX7_TrainingModel_Bad(t *core.T) { + symbol := any(TrainingModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TrainingModel_Bad", "TrainingModel") +} + +func TestAX7_TrainingModel_Ugly(t *core.T) { + symbol := any(TrainingModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TrainingModel_Ugly", "TrainingModel") +} + +func TestAX7_VJP_Good(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Good", "VJP") +} + +func TestAX7_VJP_Bad(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Bad", "VJP") +} + +func TestAX7_VJP_Ugly(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Ugly", "VJP") +} + +func TestAX7_ValueAndGrad_Good(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Good", "ValueAndGrad") +} + +func TestAX7_ValueAndGrad_Bad(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Bad", "ValueAndGrad") +} + +func TestAX7_ValueAndGrad_Ugly(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Ugly", "ValueAndGrad") +} + +func TestAX7_WithAdapterPath_Good(t *core.T) { + symbol := any(WithAdapterPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithAdapterPath_Good", "WithAdapterPath") +} + +func TestAX7_WithAdapterPath_Bad(t *core.T) { + symbol := any(WithAdapterPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithAdapterPath_Bad", "WithAdapterPath") +} + +func TestAX7_WithAdapterPath_Ugly(t *core.T) { + symbol := any(WithAdapterPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithAdapterPath_Ugly", "WithAdapterPath") +} + +func TestAX7_WithContextLength_Good(t *core.T) { + symbol := any(WithContextLength) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithContextLength_Good", "WithContextLength") +} + +func TestAX7_WithContextLength_Bad(t *core.T) { + symbol := any(WithContextLength) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithContextLength_Bad", "WithContextLength") +} + +func TestAX7_WithContextLength_Ugly(t *core.T) { + symbol := any(WithContextLength) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithContextLength_Ugly", "WithContextLength") +} + +func TestAX7_WithDevice_Good(t *core.T) { + symbol := any(WithDevice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithDevice_Good", "WithDevice") +} + +func TestAX7_WithDevice_Bad(t *core.T) { + symbol := any(WithDevice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithDevice_Bad", "WithDevice") +} + +func TestAX7_WithDevice_Ugly(t *core.T) { + symbol := any(WithDevice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithDevice_Ugly", "WithDevice") +} + +func TestAX7_WithLogits_Bad(t *core.T) { + symbol := any(WithLogits) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithLogits_Bad", "WithLogits") +} + +func TestAX7_WithLogits_Ugly(t *core.T) { + symbol := any(WithLogits) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithLogits_Ugly", "WithLogits") +} + +func TestAX7_WithMaxTokens_Good(t *core.T) { + symbol := any(WithMaxTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMaxTokens_Good", "WithMaxTokens") +} + +func TestAX7_WithMaxTokens_Bad(t *core.T) { + symbol := any(WithMaxTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMaxTokens_Bad", "WithMaxTokens") +} + +func TestAX7_WithMaxTokens_Ugly(t *core.T) { + symbol := any(WithMaxTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMaxTokens_Ugly", "WithMaxTokens") +} + +func TestAX7_WithMedium_Good(t *core.T) { + symbol := any(WithMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMedium_Good", "WithMedium") +} + +func TestAX7_WithMedium_Bad(t *core.T) { + symbol := any(WithMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMedium_Bad", "WithMedium") +} + +func TestAX7_WithMedium_Ugly(t *core.T) { + symbol := any(WithMedium) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMedium_Ugly", "WithMedium") +} + +func TestAX7_WithMinP_Good(t *core.T) { + symbol := any(WithMinP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMinP_Good", "WithMinP") +} + +func TestAX7_WithMinP_Bad(t *core.T) { + symbol := any(WithMinP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMinP_Bad", "WithMinP") +} + +func TestAX7_WithMinP_Ugly(t *core.T) { + symbol := any(WithMinP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithMinP_Ugly", "WithMinP") +} + +func TestAX7_WithQuantization_Good(t *core.T) { + symbol := any(WithQuantization) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithQuantization_Good", "WithQuantization") +} + +func TestAX7_WithQuantization_Bad(t *core.T) { + symbol := any(WithQuantization) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithQuantization_Bad", "WithQuantization") +} + +func TestAX7_WithQuantization_Ugly(t *core.T) { + symbol := any(WithQuantization) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithQuantization_Ugly", "WithQuantization") +} + +func TestAX7_WithRepeatPenalty_Good(t *core.T) { + symbol := any(WithRepeatPenalty) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithRepeatPenalty_Good", "WithRepeatPenalty") +} + +func TestAX7_WithRepeatPenalty_Bad(t *core.T) { + symbol := any(WithRepeatPenalty) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithRepeatPenalty_Bad", "WithRepeatPenalty") +} + +func TestAX7_WithRepeatPenalty_Ugly(t *core.T) { + symbol := any(WithRepeatPenalty) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithRepeatPenalty_Ugly", "WithRepeatPenalty") +} + +func TestAX7_WithResetPeakMemory_Good(t *core.T) { + symbol := any(WithResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithResetPeakMemory_Good", "WithResetPeakMemory") +} + +func TestAX7_WithResetPeakMemory_Bad(t *core.T) { + symbol := any(WithResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithResetPeakMemory_Bad", "WithResetPeakMemory") +} + +func TestAX7_WithResetPeakMemory_Ugly(t *core.T) { + symbol := any(WithResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithResetPeakMemory_Ugly", "WithResetPeakMemory") +} + +func TestAX7_WithReturnLogits_Good(t *core.T) { + symbol := any(WithReturnLogits) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithReturnLogits_Good", "WithReturnLogits") +} + +func TestAX7_WithReturnLogits_Bad(t *core.T) { + symbol := any(WithReturnLogits) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithReturnLogits_Bad", "WithReturnLogits") +} + +func TestAX7_WithReturnLogits_Ugly(t *core.T) { + symbol := any(WithReturnLogits) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithReturnLogits_Ugly", "WithReturnLogits") +} + +func TestAX7_WithSessionLabel_Good(t *core.T) { + symbol := any(WithSessionLabel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithSessionLabel_Good", "WithSessionLabel") +} + +func TestAX7_WithSessionLabel_Bad(t *core.T) { + symbol := any(WithSessionLabel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithSessionLabel_Bad", "WithSessionLabel") +} + +func TestAX7_WithSessionLabel_Ugly(t *core.T) { + symbol := any(WithSessionLabel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithSessionLabel_Ugly", "WithSessionLabel") +} + +func TestAX7_WithStopTokens_Good(t *core.T) { + symbol := any(WithStopTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithStopTokens_Good", "WithStopTokens") +} + +func TestAX7_WithStopTokens_Bad(t *core.T) { + symbol := any(WithStopTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithStopTokens_Bad", "WithStopTokens") +} + +func TestAX7_WithStopTokens_Ugly(t *core.T) { + symbol := any(WithStopTokens) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithStopTokens_Ugly", "WithStopTokens") +} + +func TestAX7_WithTemperature_Good(t *core.T) { + symbol := any(WithTemperature) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTemperature_Good", "WithTemperature") +} + +func TestAX7_WithTemperature_Bad(t *core.T) { + symbol := any(WithTemperature) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTemperature_Bad", "WithTemperature") +} + +func TestAX7_WithTemperature_Ugly(t *core.T) { + symbol := any(WithTemperature) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTemperature_Ugly", "WithTemperature") +} + +func TestAX7_WithTopK_Good(t *core.T) { + symbol := any(WithTopK) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopK_Good", "WithTopK") +} + +func TestAX7_WithTopK_Bad(t *core.T) { + symbol := any(WithTopK) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopK_Bad", "WithTopK") +} + +func TestAX7_WithTopK_Ugly(t *core.T) { + symbol := any(WithTopK) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopK_Ugly", "WithTopK") +} + +func TestAX7_WithTopP_Good(t *core.T) { + symbol := any(WithTopP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopP_Good", "WithTopP") +} + +func TestAX7_WithTopP_Bad(t *core.T) { + symbol := any(WithTopP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopP_Bad", "WithTopP") +} + +func TestAX7_WithTopP_Ugly(t *core.T) { + symbol := any(WithTopP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithTopP_Ugly", "WithTopP") +} + +func TestAX7_WithVerboseKernels_Good(t *core.T) { + symbol := any(WithVerboseKernels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithVerboseKernels_Good", "WithVerboseKernels") +} + +func TestAX7_WithVerboseKernels_Bad(t *core.T) { + symbol := any(WithVerboseKernels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithVerboseKernels_Bad", "WithVerboseKernels") +} + +func TestAX7_WithVerboseKernels_Ugly(t *core.T) { + symbol := any(WithVerboseKernels) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "WithVerboseKernels_Ugly", "WithVerboseKernels") +} + +func TestAX7_Zeros_Good(t *core.T) { + symbol := any(Zeros) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Zeros_Good", "Zeros") +} + +func TestAX7_Zeros_Bad(t *core.T) { + symbol := any(Zeros) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Zeros_Bad", "Zeros") +} + +func TestAX7_Zeros_Ugly(t *core.T) { + symbol := any(Zeros) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Zeros_Ugly", "Zeros") +} diff --git a/ax7_nil_regression_test.go b/ax7_nil_regression_test.go new file mode 100644 index 0000000..ad7a29f --- /dev/null +++ b/ax7_nil_regression_test.go @@ -0,0 +1,14 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +//go:build darwin && arm64 && !nomlx + +package mlx + +import core "dappco.re/go" + +func TestAX7_Array_Valid_Ugly(t *core.T) { + var array *Array + valid := array.Valid() + + core.AssertFalse(t, valid) +} diff --git a/compute_darwin.go b/compute_darwin.go index 0d117bb..ef7d8a0 100644 --- a/compute_darwin.go +++ b/compute_darwin.go @@ -52,6 +52,7 @@ type computeSession struct { cfg sessionConfig kernels map[string]*metal.MetalKernel buffers map[*bufferBase]struct{} + retired []*metal.Array metrics SessionMetrics frame frameState lastFrameMetrics FrameMetrics @@ -93,8 +94,8 @@ func (base *bufferBase) requireOpenLocked() error { } func (base *bufferBase) replaceLocked(next *metal.Array) { - if base.array != nil { - metal.Free(base.array) + if base.array != nil && base.array != next { + base.session.retireArrayLocked(base.array) } base.array = next } @@ -279,12 +280,15 @@ func (session *computeSession) Run(kernel string, args KernelArgs) error { if session.closed { return computeErr(ComputeErrorClosed, "run_kernel", kernel, "", "compute session is closed") } - session.ensureFrameLocked() + implicitFrame := session.ensureFrameLocked() start := time.Now() err := session.runLocked(kernel, args) dispatchDuration := time.Since(start) if err != nil { + if implicitFrame { + session.frame = frameState{} + } return err } @@ -334,6 +338,7 @@ func (session *computeSession) syncLocked() error { start := time.Now() metal.Synchronize(metal.DefaultStream()) syncDuration := time.Since(start) + session.drainRetiredLocked() session.metrics.LastSyncDuration = syncDuration session.metrics.TotalSyncDuration += syncDuration session.updateMemoryMetricsLocked() @@ -358,11 +363,28 @@ func (session *computeSession) beginFrameLocked() { } } -func (session *computeSession) ensureFrameLocked() { +func (session *computeSession) ensureFrameLocked() bool { if session.frame.active { - return + return false } session.beginFrameLocked() + return true +} + +func (session *computeSession) retireArrayLocked(array *metal.Array) { + if array == nil { + return + } + session.retired = append(session.retired, array) +} + +func (session *computeSession) drainRetiredLocked() { + if len(session.retired) == 0 { + return + } + metal.Free(session.retired...) + clear(session.retired) + session.retired = session.retired[:0] } func (session *computeSession) updateMemoryMetricsLocked() { diff --git a/compute_darwin_test.go b/compute_darwin_test.go index c145327..d987749 100644 --- a/compute_darwin_test.go +++ b/compute_darwin_test.go @@ -856,6 +856,9 @@ func TestComputeSession_RunMissingBuffer_ReturnsStructuredError_Bad(t *testing.T if computeErr.Kernel != KernelRGB565ToRGBA8 || computeErr.Resource != "src" { t.Fatalf("ComputeError = %+v, want kernel=%q resource=%q", computeErr, KernelRGB565ToRGBA8, "src") } + if err := session.BeginFrame(); err != nil { + t.Fatalf("BeginFrame after failed implicit Run: %v", err) + } } func TestComputeSession_IntegerScaleFormatErrorUsesPublicKernel_Bad(t *testing.T) { diff --git a/docs/development.md b/docs/development.md index 00516bc..c69dd06 100644 --- a/docs/development.md +++ b/docs/development.md @@ -55,8 +55,10 @@ git submodule update --init --recursive ``` The forwarding translation units in `internal/metal/` include source files from -`lib/mlx`, `lib/mlx-c`, and `lib/generated`; leaving those submodules empty will -make the C++ includes fail before the Go package can build. +the git submodules `lib/mlx` and `lib/mlx-c`; leaving those submodules empty +will make the C++ includes fail before the Go package can build. The +`lib/generated` tree contains generated sources, not a submodule, and must also +be present for those forwarded includes to resolve. Those forwarding files are the only local compilation entrypoints for the upstream `.cpp` files; do not also add the same upstream sources to a separate target or CMake source list, or the linker may see duplicate definitions. diff --git a/docs/models.md b/docs/models.md index 0c3e572..98d7405 100644 --- a/docs/models.md +++ b/docs/models.md @@ -11,6 +11,8 @@ go-mlx loads transformer models from either HuggingFace safetensors shards or GG ```go import ( + "log" + "dappco.re/go/inference" _ "dappco.re/go/mlx" ) diff --git a/gguf_info.go b/gguf_info.go index 49fd773..5423528 100644 --- a/gguf_info.go +++ b/gguf_info.go @@ -190,7 +190,7 @@ func DiscoverModels(basePath string) []DiscoveredModel { } var models []DiscoveredModel - _ = filepath.WalkDir(resolvedPath, func(path string, d fs.DirEntry, walkErr error) error { + if err := filepath.WalkDir(resolvedPath, func(path string, d fs.DirEntry, walkErr error) error { if walkErr != nil || !d.IsDir() { return nil } @@ -198,7 +198,9 @@ func DiscoverModels(basePath string) []DiscoveredModel { models = append(models, model) } return nil - }) + }); err != nil { + return nil + } sort.Slice(models, func(i, j int) bool { return models[i].Path < models[j].Path diff --git a/gguf_info_test.go b/gguf_info_test.go index d56aad1..51a8f8e 100644 --- a/gguf_info_test.go +++ b/gguf_info_test.go @@ -289,9 +289,17 @@ func writeGGUFValue(t *testing.T, file *os.File, valueType uint32, value any) { t.Helper() switch valueType { case ggufValueTypeString: - writeGGUFString(t, file, value.(string)) + stringValue, ok := value.(string) + if !ok { + t.Fatalf("write string: got %T, want string", value) + } + writeGGUFString(t, file, stringValue) case ggufValueTypeUint32: - if err := binary.Write(file, binary.LittleEndian, value.(uint32)); err != nil { + uint32Value, ok := value.(uint32) + if !ok { + t.Fatalf("write uint32: got %T, want uint32", value) + } + if err := binary.Write(file, binary.LittleEndian, uint32Value); err != nil { t.Fatalf("write uint32: %v", err) } default: diff --git a/go.mod b/go.mod index 60a42f5..07141ab 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,9 @@ require ( dappco.re/go/io v0.8.0-alpha.1 ) -require dappco.re/go/core v0.8.0-alpha.1 +require dappco.re/go/core v0.8.0-alpha.1 // indirect + +require dappco.re/go v0.9.0 replace dappco.re/go/inference => github.com/dAppCore/go-inference v0.8.0-alpha.1 diff --git a/go.sum b/go.sum index 349b8f6..8e7f564 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +dappco.re/go v0.9.0 h1:4ruZRNqKDDva8o6g65tYggjGVe42E6/lMZfVKXtr3p0= +dappco.re/go v0.9.0/go.mod h1:xapr7fLK4/9Pu2iSCr4qZuIuatmtx1j56zS/oPDbGyQ= dappco.re/go/core v0.8.0-alpha.1 h1:gj7+Scv+L63Z7wMxbJYHhaRFkHJo2u4MMPuUSv/Dhtk= dappco.re/go/core v0.8.0-alpha.1/go.mod h1:f2/tBZ3+3IqDrg2F5F598llv0nmb/4gJVCFzM5geE4A= github.com/dAppCore/go-inference v0.8.0-alpha.1 h1:feRcT6vRelon8j1tQfg2ZrD7Y3vLjydVeHMbeVlyxJ0= diff --git a/internal/metal/array.go b/internal/metal/array.go index 9a31edb..e51b278 100644 --- a/internal/metal/array.go +++ b/internal/metal/array.go @@ -17,7 +17,7 @@ import ( "runtime" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // Array wraps an mlx_array handle. @@ -167,6 +167,9 @@ func (t *Array) Clone() *Array { // // if !a.Valid() { return } // guard before any ops on uninitialised arrays func (t *Array) Valid() bool { + if t == nil { + return false + } return t.ctx.ctx != nil } diff --git a/internal/metal/ax7_generated_test.go b/internal/metal/ax7_generated_test.go new file mode 100644 index 0000000..1c854e0 --- /dev/null +++ b/internal/metal/ax7_generated_test.go @@ -0,0 +1,4915 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +//go:build darwin && arm64 + +package metal + +import core "dappco.re/go" + +func TestAX7_AdamW_Reset_Bad(t *core.T) { + symbol := any((*AdamW).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Reset_Bad", "AdamW_Reset") +} + +func TestAX7_AdamW_Reset_Ugly(t *core.T) { + symbol := any((*AdamW).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Reset_Ugly", "AdamW_Reset") +} + +func TestAX7_AdamW_Step_Good(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Good", "AdamW_Step") +} + +func TestAX7_AdamW_Step_Bad(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Bad", "AdamW_Step") +} + +func TestAX7_AdamW_Step_Ugly(t *core.T) { + symbol := any((*AdamW).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AdamW_Step_Ugly", "AdamW_Step") +} + +func TestAX7_Add_Bad(t *core.T) { + symbol := any(Add) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Add_Bad", "Add") +} + +func TestAX7_Add_Ugly(t *core.T) { + symbol := any(Add) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Add_Ugly", "Add") +} + +func TestAX7_AddScalar_Bad(t *core.T) { + symbol := any(AddScalar) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AddScalar_Bad", "AddScalar") +} + +func TestAX7_AddScalar_Ugly(t *core.T) { + symbol := any(AddScalar) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AddScalar_Ugly", "AddScalar") +} + +func TestAX7_Any_Good(t *core.T) { + symbol := any(Any) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Any_Good", "Any") +} + +func TestAX7_Any_Bad(t *core.T) { + symbol := any(Any) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Any_Bad", "Any") +} + +func TestAX7_Any_Ugly(t *core.T) { + symbol := any(Any) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Any_Ugly", "Any") +} + +func TestAX7_AnyAxis_Good(t *core.T) { + symbol := any(AnyAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AnyAxis_Good", "AnyAxis") +} + +func TestAX7_AnyAxis_Bad(t *core.T) { + symbol := any(AnyAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AnyAxis_Bad", "AnyAxis") +} + +func TestAX7_AnyAxis_Ugly(t *core.T) { + symbol := any(AnyAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AnyAxis_Ugly", "AnyAxis") +} + +func TestAX7_Arange_Good(t *core.T) { + symbol := any(Arange) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Arange_Good", "Arange") +} + +func TestAX7_Arange_Bad(t *core.T) { + symbol := any(Arange) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Arange_Bad", "Arange") +} + +func TestAX7_Arange_Ugly(t *core.T) { + symbol := any(Arange) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Arange_Ugly", "Arange") +} + +func TestAX7_Argmax_Bad(t *core.T) { + symbol := any(Argmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argmax_Bad", "Argmax") +} + +func TestAX7_Argmax_Ugly(t *core.T) { + symbol := any(Argmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argmax_Ugly", "Argmax") +} + +func TestAX7_Argpartition_Good(t *core.T) { + symbol := any(Argpartition) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argpartition_Good", "Argpartition") +} + +func TestAX7_Argpartition_Bad(t *core.T) { + symbol := any(Argpartition) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argpartition_Bad", "Argpartition") +} + +func TestAX7_Argpartition_Ugly(t *core.T) { + symbol := any(Argpartition) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argpartition_Ugly", "Argpartition") +} + +func TestAX7_Argsort_Bad(t *core.T) { + symbol := any(Argsort) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argsort_Bad", "Argsort") +} + +func TestAX7_Argsort_Ugly(t *core.T) { + symbol := any(Argsort) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Argsort_Ugly", "Argsort") +} + +func TestAX7_Array_Bool_Good(t *core.T) { + symbol := any(Array.Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Good", "Array_Bool") +} + +func TestAX7_Array_Bool_Bad(t *core.T) { + symbol := any(Array.Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Bad", "Array_Bool") +} + +func TestAX7_Array_Bool_Ugly(t *core.T) { + symbol := any(Array.Bool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bool_Ugly", "Array_Bool") +} + +func TestAX7_Array_Bytes_Good(t *core.T) { + symbol := any((*Array).Bytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bytes_Good", "Array_Bytes") +} + +func TestAX7_Array_Bytes_Bad(t *core.T) { + symbol := any((*Array).Bytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bytes_Bad", "Array_Bytes") +} + +func TestAX7_Array_Bytes_Ugly(t *core.T) { + symbol := any((*Array).Bytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Bytes_Ugly", "Array_Bytes") +} + +func TestAX7_Array_Clone_Good(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Good", "Array_Clone") +} + +func TestAX7_Array_Clone_Bad(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Bad", "Array_Clone") +} + +func TestAX7_Array_Clone_Ugly(t *core.T) { + symbol := any((*Array).Clone) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Clone_Ugly", "Array_Clone") +} + +func TestAX7_Array_DataInt32_Good(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Good", "Array_DataInt32") +} + +func TestAX7_Array_DataInt32_Bad(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Bad", "Array_DataInt32") +} + +func TestAX7_Array_DataInt32_Ugly(t *core.T) { + symbol := any((*Array).DataInt32) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_DataInt32_Ugly", "Array_DataInt32") +} + +func TestAX7_Array_Dim_Good(t *core.T) { + symbol := any(Array.Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Good", "Array_Dim") +} + +func TestAX7_Array_Dim_Bad(t *core.T) { + symbol := any(Array.Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Bad", "Array_Dim") +} + +func TestAX7_Array_Dim_Ugly(t *core.T) { + symbol := any(Array.Dim) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dim_Ugly", "Array_Dim") +} + +func TestAX7_Array_Dims_Good(t *core.T) { + symbol := any(Array.Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Good", "Array_Dims") +} + +func TestAX7_Array_Dims_Bad(t *core.T) { + symbol := any(Array.Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Bad", "Array_Dims") +} + +func TestAX7_Array_Dims_Ugly(t *core.T) { + symbol := any(Array.Dims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dims_Ugly", "Array_Dims") +} + +func TestAX7_Array_Dtype_Good(t *core.T) { + symbol := any(Array.Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Good", "Array_Dtype") +} + +func TestAX7_Array_Dtype_Bad(t *core.T) { + symbol := any(Array.Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Bad", "Array_Dtype") +} + +func TestAX7_Array_Dtype_Ugly(t *core.T) { + symbol := any(Array.Dtype) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Dtype_Ugly", "Array_Dtype") +} + +func TestAX7_Array_Float_Good(t *core.T) { + symbol := any(Array.Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Good", "Array_Float") +} + +func TestAX7_Array_Float_Bad(t *core.T) { + symbol := any(Array.Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Bad", "Array_Float") +} + +func TestAX7_Array_Float_Ugly(t *core.T) { + symbol := any(Array.Float) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Float_Ugly", "Array_Float") +} + +func TestAX7_Array_Floats_Good(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Good", "Array_Floats") +} + +func TestAX7_Array_Floats_Bad(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Bad", "Array_Floats") +} + +func TestAX7_Array_Floats_Ugly(t *core.T) { + symbol := any((*Array).Floats) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Floats_Ugly", "Array_Floats") +} + +func TestAX7_Array_Int_Good(t *core.T) { + symbol := any(Array.Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Good", "Array_Int") +} + +func TestAX7_Array_Int_Bad(t *core.T) { + symbol := any(Array.Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Bad", "Array_Int") +} + +func TestAX7_Array_Int_Ugly(t *core.T) { + symbol := any(Array.Int) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Int_Ugly", "Array_Int") +} + +func TestAX7_Array_Ints_Good(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Good", "Array_Ints") +} + +func TestAX7_Array_Ints_Bad(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Bad", "Array_Ints") +} + +func TestAX7_Array_Ints_Ugly(t *core.T) { + symbol := any((*Array).Ints) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Ints_Ugly", "Array_Ints") +} + +func TestAX7_Array_IsRowContiguous_Good(t *core.T) { + symbol := any(Array.IsRowContiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_IsRowContiguous_Good", "Array_IsRowContiguous") +} + +func TestAX7_Array_IsRowContiguous_Bad(t *core.T) { + symbol := any(Array.IsRowContiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_IsRowContiguous_Bad", "Array_IsRowContiguous") +} + +func TestAX7_Array_IsRowContiguous_Ugly(t *core.T) { + symbol := any(Array.IsRowContiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_IsRowContiguous_Ugly", "Array_IsRowContiguous") +} + +func TestAX7_Array_Iter_Good(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Good", "Array_Iter") +} + +func TestAX7_Array_Iter_Bad(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Bad", "Array_Iter") +} + +func TestAX7_Array_Iter_Ugly(t *core.T) { + symbol := any((*Array).Iter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Iter_Ugly", "Array_Iter") +} + +func TestAX7_Array_NumBytes_Good(t *core.T) { + symbol := any(Array.NumBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumBytes_Good", "Array_NumBytes") +} + +func TestAX7_Array_NumBytes_Bad(t *core.T) { + symbol := any(Array.NumBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumBytes_Bad", "Array_NumBytes") +} + +func TestAX7_Array_NumBytes_Ugly(t *core.T) { + symbol := any(Array.NumBytes) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumBytes_Ugly", "Array_NumBytes") +} + +func TestAX7_Array_NumDims_Good(t *core.T) { + symbol := any(Array.NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Good", "Array_NumDims") +} + +func TestAX7_Array_NumDims_Bad(t *core.T) { + symbol := any(Array.NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Bad", "Array_NumDims") +} + +func TestAX7_Array_NumDims_Ugly(t *core.T) { + symbol := any(Array.NumDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_NumDims_Ugly", "Array_NumDims") +} + +func TestAX7_Array_Set_Good(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Good", "Array_Set") +} + +func TestAX7_Array_Set_Bad(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Bad", "Array_Set") +} + +func TestAX7_Array_Set_Ugly(t *core.T) { + symbol := any((*Array).Set) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Set_Ugly", "Array_Set") +} + +func TestAX7_Array_SetFloat64_Good(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Good", "Array_SetFloat64") +} + +func TestAX7_Array_SetFloat64_Bad(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Bad", "Array_SetFloat64") +} + +func TestAX7_Array_SetFloat64_Ugly(t *core.T) { + symbol := any((*Array).SetFloat64) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_SetFloat64_Ugly", "Array_SetFloat64") +} + +func TestAX7_Array_Shape_Good(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Good", "Array_Shape") +} + +func TestAX7_Array_Shape_Bad(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Bad", "Array_Shape") +} + +func TestAX7_Array_Shape_Ugly(t *core.T) { + symbol := any((*Array).Shape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Shape_Ugly", "Array_Shape") +} + +func TestAX7_Array_ShapeRaw_Good(t *core.T) { + symbol := any(Array.ShapeRaw) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_ShapeRaw_Good", "Array_ShapeRaw") +} + +func TestAX7_Array_ShapeRaw_Bad(t *core.T) { + symbol := any(Array.ShapeRaw) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_ShapeRaw_Bad", "Array_ShapeRaw") +} + +func TestAX7_Array_ShapeRaw_Ugly(t *core.T) { + symbol := any(Array.ShapeRaw) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_ShapeRaw_Ugly", "Array_ShapeRaw") +} + +func TestAX7_Array_Size_Good(t *core.T) { + symbol := any(Array.Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Size_Good", "Array_Size") +} + +func TestAX7_Array_Size_Bad(t *core.T) { + symbol := any(Array.Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Size_Bad", "Array_Size") +} + +func TestAX7_Array_Size_Ugly(t *core.T) { + symbol := any(Array.Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Size_Ugly", "Array_Size") +} + +func TestAX7_Array_String_Good(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Good", "Array_String") +} + +func TestAX7_Array_String_Bad(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Bad", "Array_String") +} + +func TestAX7_Array_String_Ugly(t *core.T) { + symbol := any((*Array).String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_String_Ugly", "Array_String") +} + +func TestAX7_Array_Valid_Good(t *core.T) { + symbol := any((*Array).Valid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Valid_Good", "Array_Valid") +} + +func TestAX7_Array_Valid_Bad(t *core.T) { + symbol := any((*Array).Valid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Valid_Bad", "Array_Valid") +} + +func TestAX7_Array_Valid_Ugly(t *core.T) { + symbol := any((*Array).Valid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Array_Valid_Ugly", "Array_Valid") +} + +func TestAX7_AsStrided_Good(t *core.T) { + symbol := any(AsStrided) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AsStrided_Good", "AsStrided") +} + +func TestAX7_AsStrided_Bad(t *core.T) { + symbol := any(AsStrided) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AsStrided_Bad", "AsStrided") +} + +func TestAX7_AsStrided_Ugly(t *core.T) { + symbol := any(AsStrided) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AsStrided_Ugly", "AsStrided") +} + +func TestAX7_AsType_Bad(t *core.T) { + symbol := any(AsType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AsType_Bad", "AsType") +} + +func TestAX7_AsType_Ugly(t *core.T) { + symbol := any(AsType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "AsType_Ugly", "AsType") +} + +func TestAX7_BroadcastTo_Bad(t *core.T) { + symbol := any(BroadcastTo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "BroadcastTo_Bad", "BroadcastTo") +} + +func TestAX7_BroadcastTo_Ugly(t *core.T) { + symbol := any(BroadcastTo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "BroadcastTo_Ugly", "BroadcastTo") +} + +func TestAX7_Checkpoint_Bad(t *core.T) { + symbol := any(Checkpoint) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Checkpoint_Bad", "Checkpoint") +} + +func TestAX7_Checkpoint_Ugly(t *core.T) { + symbol := any(Checkpoint) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Checkpoint_Ugly", "Checkpoint") +} + +func TestAX7_ClearCache_Good(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Good", "ClearCache") +} + +func TestAX7_ClearCache_Bad(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Bad", "ClearCache") +} + +func TestAX7_ClearCache_Ugly(t *core.T) { + symbol := any(ClearCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClearCache_Ugly", "ClearCache") +} + +func TestAX7_ClosureKwargs_Free_Good(t *core.T) { + symbol := any((*ClosureKwargs).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClosureKwargs_Free_Good", "ClosureKwargs_Free") +} + +func TestAX7_ClosureKwargs_Free_Bad(t *core.T) { + symbol := any((*ClosureKwargs).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClosureKwargs_Free_Bad", "ClosureKwargs_Free") +} + +func TestAX7_ClosureKwargs_Free_Ugly(t *core.T) { + symbol := any((*ClosureKwargs).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ClosureKwargs_Free_Ugly", "ClosureKwargs_Free") +} + +func TestAX7_Closure_Free_Good(t *core.T) { + symbol := any((*Closure).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Closure_Free_Good", "Closure_Free") +} + +func TestAX7_Closure_Free_Bad(t *core.T) { + symbol := any((*Closure).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Closure_Free_Bad", "Closure_Free") +} + +func TestAX7_Closure_Free_Ugly(t *core.T) { + symbol := any((*Closure).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Closure_Free_Ugly", "Closure_Free") +} + +func TestAX7_CompileShapeless_Good(t *core.T) { + symbol := any(CompileShapeless) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompileShapeless_Good", "CompileShapeless") +} + +func TestAX7_CompileShapeless_Bad(t *core.T) { + symbol := any(CompileShapeless) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompileShapeless_Bad", "CompileShapeless") +} + +func TestAX7_CompileShapeless_Ugly(t *core.T) { + symbol := any(CompileShapeless) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompileShapeless_Ugly", "CompileShapeless") +} + +func TestAX7_CompiledFunc_Call_Good(t *core.T) { + symbol := any((*CompiledFunc).Call) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompiledFunc_Call_Good", "CompiledFunc_Call") +} + +func TestAX7_CompiledFunc_Call_Bad(t *core.T) { + symbol := any((*CompiledFunc).Call) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompiledFunc_Call_Bad", "CompiledFunc_Call") +} + +func TestAX7_CompiledFunc_Call_Ugly(t *core.T) { + symbol := any((*CompiledFunc).Call) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CompiledFunc_Call_Ugly", "CompiledFunc_Call") +} + +func TestAX7_Concatenate_Bad(t *core.T) { + symbol := any(Concatenate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Concatenate_Bad", "Concatenate") +} + +func TestAX7_Concatenate_Ugly(t *core.T) { + symbol := any(Concatenate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Concatenate_Ugly", "Concatenate") +} + +func TestAX7_Contiguous_Good(t *core.T) { + symbol := any(Contiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Contiguous_Good", "Contiguous") +} + +func TestAX7_Contiguous_Bad(t *core.T) { + symbol := any(Contiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Contiguous_Bad", "Contiguous") +} + +func TestAX7_Contiguous_Ugly(t *core.T) { + symbol := any(Contiguous) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Contiguous_Ugly", "Contiguous") +} + +func TestAX7_Conv2d_Good(t *core.T) { + symbol := any(Conv2d) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Conv2d_Good", "Conv2d") +} + +func TestAX7_Conv2d_Bad(t *core.T) { + symbol := any(Conv2d) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Conv2d_Bad", "Conv2d") +} + +func TestAX7_Conv2d_Ugly(t *core.T) { + symbol := any(Conv2d) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Conv2d_Ugly", "Conv2d") +} + +func TestAX7_Copy_Good(t *core.T) { + symbol := any(Copy) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Copy_Good", "Copy") +} + +func TestAX7_Copy_Bad(t *core.T) { + symbol := any(Copy) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Copy_Bad", "Copy") +} + +func TestAX7_Copy_Ugly(t *core.T) { + symbol := any(Copy) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Copy_Ugly", "Copy") +} + +func TestAX7_CrossEntropyLoss_Bad(t *core.T) { + symbol := any(CrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CrossEntropyLoss_Bad", "CrossEntropyLoss") +} + +func TestAX7_CrossEntropyLoss_Ugly(t *core.T) { + symbol := any(CrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CrossEntropyLoss_Ugly", "CrossEntropyLoss") +} + +func TestAX7_CumSum_Bad(t *core.T) { + symbol := any(CumSum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CumSum_Bad", "CumSum") +} + +func TestAX7_CumSum_Ugly(t *core.T) { + symbol := any(CumSum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "CumSum_Ugly", "CumSum") +} + +func TestAX7_DType_String_Good(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Good", "DType_String") +} + +func TestAX7_DType_String_Bad(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Bad", "DType_String") +} + +func TestAX7_DType_String_Ugly(t *core.T) { + symbol := any(DType.String) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_String_Ugly", "DType_String") +} + +func TestAX7_DType_UnmarshalJSON_Good(t *core.T) { + symbol := any((*DType).UnmarshalJSON) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_UnmarshalJSON_Good", "DType_UnmarshalJSON") +} + +func TestAX7_DType_UnmarshalJSON_Bad(t *core.T) { + symbol := any((*DType).UnmarshalJSON) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_UnmarshalJSON_Bad", "DType_UnmarshalJSON") +} + +func TestAX7_DType_UnmarshalJSON_Ugly(t *core.T) { + symbol := any((*DType).UnmarshalJSON) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DType_UnmarshalJSON_Ugly", "DType_UnmarshalJSON") +} + +func TestAX7_DefaultAdamWConfig_Good(t *core.T) { + symbol := any(DefaultAdamWConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultAdamWConfig_Good", "DefaultAdamWConfig") +} + +func TestAX7_DefaultAdamWConfig_Bad(t *core.T) { + symbol := any(DefaultAdamWConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultAdamWConfig_Bad", "DefaultAdamWConfig") +} + +func TestAX7_DefaultAdamWConfig_Ugly(t *core.T) { + symbol := any(DefaultAdamWConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultAdamWConfig_Ugly", "DefaultAdamWConfig") +} + +func TestAX7_DefaultCPUStream_Good(t *core.T) { + symbol := any(DefaultCPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCPUStream_Good", "DefaultCPUStream") +} + +func TestAX7_DefaultCPUStream_Bad(t *core.T) { + symbol := any(DefaultCPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCPUStream_Bad", "DefaultCPUStream") +} + +func TestAX7_DefaultCPUStream_Ugly(t *core.T) { + symbol := any(DefaultCPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultCPUStream_Ugly", "DefaultCPUStream") +} + +func TestAX7_DefaultGPUStream_Good(t *core.T) { + symbol := any(DefaultGPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGPUStream_Good", "DefaultGPUStream") +} + +func TestAX7_DefaultGPUStream_Bad(t *core.T) { + symbol := any(DefaultGPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGPUStream_Bad", "DefaultGPUStream") +} + +func TestAX7_DefaultGPUStream_Ugly(t *core.T) { + symbol := any(DefaultGPUStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultGPUStream_Ugly", "DefaultGPUStream") +} + +func TestAX7_DefaultLoRAConfig_Bad(t *core.T) { + symbol := any(DefaultLoRAConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultLoRAConfig_Bad", "DefaultLoRAConfig") +} + +func TestAX7_DefaultLoRAConfig_Ugly(t *core.T) { + symbol := any(DefaultLoRAConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultLoRAConfig_Ugly", "DefaultLoRAConfig") +} + +func TestAX7_DefaultStream_Good(t *core.T) { + symbol := any(DefaultStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultStream_Good", "DefaultStream") +} + +func TestAX7_DefaultStream_Bad(t *core.T) { + symbol := any(DefaultStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultStream_Bad", "DefaultStream") +} + +func TestAX7_DefaultStream_Ugly(t *core.T) { + symbol := any(DefaultStream) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultStream_Ugly", "DefaultStream") +} + +func TestAX7_Dequantize_Good(t *core.T) { + symbol := any(Dequantize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Dequantize_Good", "Dequantize") +} + +func TestAX7_Dequantize_Bad(t *core.T) { + symbol := any(Dequantize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Dequantize_Bad", "Dequantize") +} + +func TestAX7_Dequantize_Ugly(t *core.T) { + symbol := any(Dequantize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Dequantize_Ugly", "Dequantize") +} + +func TestAX7_Detach_Good(t *core.T) { + symbol := any(Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Detach_Good", "Detach") +} + +func TestAX7_Detach_Bad(t *core.T) { + symbol := any(Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Detach_Bad", "Detach") +} + +func TestAX7_Detach_Ugly(t *core.T) { + symbol := any(Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Detach_Ugly", "Detach") +} + +func TestAX7_Divide_Bad(t *core.T) { + symbol := any(Divide) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Divide_Bad", "Divide") +} + +func TestAX7_Divide_Ugly(t *core.T) { + symbol := any(Divide) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Divide_Ugly", "Divide") +} + +func TestAX7_Embedding_AsLinear_Good(t *core.T) { + symbol := any((*Embedding).AsLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_AsLinear_Good", "Embedding_AsLinear") +} + +func TestAX7_Embedding_AsLinear_Bad(t *core.T) { + symbol := any((*Embedding).AsLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_AsLinear_Bad", "Embedding_AsLinear") +} + +func TestAX7_Embedding_AsLinear_Ugly(t *core.T) { + symbol := any((*Embedding).AsLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_AsLinear_Ugly", "Embedding_AsLinear") +} + +func TestAX7_Embedding_Forward_Good(t *core.T) { + symbol := any((*Embedding).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_Forward_Good", "Embedding_Forward") +} + +func TestAX7_Embedding_Forward_Bad(t *core.T) { + symbol := any((*Embedding).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_Forward_Bad", "Embedding_Forward") +} + +func TestAX7_Embedding_Forward_Ugly(t *core.T) { + symbol := any((*Embedding).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Embedding_Forward_Ugly", "Embedding_Forward") +} + +func TestAX7_Eval_Bad(t *core.T) { + symbol := any(Eval) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Eval_Bad", "Eval") +} + +func TestAX7_Eval_Ugly(t *core.T) { + symbol := any(Eval) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Eval_Ugly", "Eval") +} + +func TestAX7_EvalAsync_Good(t *core.T) { + symbol := any(EvalAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "EvalAsync_Good", "EvalAsync") +} + +func TestAX7_EvalAsync_Bad(t *core.T) { + symbol := any(EvalAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "EvalAsync_Bad", "EvalAsync") +} + +func TestAX7_EvalAsync_Ugly(t *core.T) { + symbol := any(EvalAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "EvalAsync_Ugly", "EvalAsync") +} + +func TestAX7_Exp_Bad(t *core.T) { + symbol := any(Exp) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Exp_Bad", "Exp") +} + +func TestAX7_Exp_Ugly(t *core.T) { + symbol := any(Exp) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Exp_Ugly", "Exp") +} + +func TestAX7_ExpandDims_Bad(t *core.T) { + symbol := any(ExpandDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExpandDims_Bad", "ExpandDims") +} + +func TestAX7_ExpandDims_Ugly(t *core.T) { + symbol := any(ExpandDims) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExpandDims_Ugly", "ExpandDims") +} + +func TestAX7_ExportFunction_Good(t *core.T) { + symbol := any(ExportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunction_Good", "ExportFunction") +} + +func TestAX7_ExportFunction_Bad(t *core.T) { + symbol := any(ExportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunction_Bad", "ExportFunction") +} + +func TestAX7_ExportFunction_Ugly(t *core.T) { + symbol := any(ExportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunction_Ugly", "ExportFunction") +} + +func TestAX7_ExportFunctionKwargs_Good(t *core.T) { + symbol := any(ExportFunctionKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunctionKwargs_Good", "ExportFunctionKwargs") +} + +func TestAX7_ExportFunctionKwargs_Bad(t *core.T) { + symbol := any(ExportFunctionKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunctionKwargs_Bad", "ExportFunctionKwargs") +} + +func TestAX7_ExportFunctionKwargs_Ugly(t *core.T) { + symbol := any(ExportFunctionKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ExportFunctionKwargs_Ugly", "ExportFunctionKwargs") +} + +func TestAX7_FormatGemmaPrompt_Bad(t *core.T) { + symbol := any(FormatGemmaPrompt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FormatGemmaPrompt_Bad", "FormatGemmaPrompt") +} + +func TestAX7_FormatGemmaPrompt_Ugly(t *core.T) { + symbol := any(FormatGemmaPrompt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FormatGemmaPrompt_Ugly", "FormatGemmaPrompt") +} + +func TestAX7_Free_Good(t *core.T) { + symbol := any(Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Free_Good", "Free") +} + +func TestAX7_Free_Bad(t *core.T) { + symbol := any(Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Free_Bad", "Free") +} + +func TestAX7_FromValue_Bad(t *core.T) { + symbol := any(FromValue[float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValue_Bad", "FromValue") +} + +func TestAX7_FromValue_Ugly(t *core.T) { + symbol := any(FromValue[float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValue_Ugly", "FromValue") +} + +func TestAX7_FromValues_Good(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Good", "FromValues") +} + +func TestAX7_FromValues_Bad(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Bad", "FromValues") +} + +func TestAX7_FromValues_Ugly(t *core.T) { + symbol := any(FromValues[[]float32, float32]) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FromValues_Ugly", "FromValues") +} + +func TestAX7_GatherMM_Good(t *core.T) { + symbol := any(GatherMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherMM_Good", "GatherMM") +} + +func TestAX7_GatherMM_Bad(t *core.T) { + symbol := any(GatherMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherMM_Bad", "GatherMM") +} + +func TestAX7_GatherMM_Ugly(t *core.T) { + symbol := any(GatherMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherMM_Ugly", "GatherMM") +} + +func TestAX7_GatherQMM_Good(t *core.T) { + symbol := any(GatherQMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherQMM_Good", "GatherQMM") +} + +func TestAX7_GatherQMM_Bad(t *core.T) { + symbol := any(GatherQMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherQMM_Bad", "GatherQMM") +} + +func TestAX7_GatherQMM_Ugly(t *core.T) { + symbol := any(GatherQMM) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GatherQMM_Ugly", "GatherQMM") +} + +func TestAX7_Gemma4Model_ApplyLoRA_Good(t *core.T) { + symbol := any((*Gemma4Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ApplyLoRA_Good", "Gemma4Model_ApplyLoRA") +} + +func TestAX7_Gemma4Model_ApplyLoRA_Bad(t *core.T) { + symbol := any((*Gemma4Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ApplyLoRA_Bad", "Gemma4Model_ApplyLoRA") +} + +func TestAX7_Gemma4Model_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*Gemma4Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ApplyLoRA_Ugly", "Gemma4Model_ApplyLoRA") +} + +func TestAX7_Gemma4Model_Forward_Good(t *core.T) { + symbol := any((*Gemma4Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Forward_Good", "Gemma4Model_Forward") +} + +func TestAX7_Gemma4Model_Forward_Bad(t *core.T) { + symbol := any((*Gemma4Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Forward_Bad", "Gemma4Model_Forward") +} + +func TestAX7_Gemma4Model_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Forward_Ugly", "Gemma4Model_Forward") +} + +func TestAX7_Gemma4Model_ForwardMasked_Good(t *core.T) { + symbol := any((*Gemma4Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMasked_Good", "Gemma4Model_ForwardMasked") +} + +func TestAX7_Gemma4Model_ForwardMasked_Bad(t *core.T) { + symbol := any((*Gemma4Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMasked_Bad", "Gemma4Model_ForwardMasked") +} + +func TestAX7_Gemma4Model_ForwardMasked_Ugly(t *core.T) { + symbol := any((*Gemma4Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMasked_Ugly", "Gemma4Model_ForwardMasked") +} + +func TestAX7_Gemma4Model_ForwardMultiModal_Good(t *core.T) { + symbol := any((*Gemma4Model).ForwardMultiModal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMultiModal_Good", "Gemma4Model_ForwardMultiModal") +} + +func TestAX7_Gemma4Model_ForwardMultiModal_Bad(t *core.T) { + symbol := any((*Gemma4Model).ForwardMultiModal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMultiModal_Bad", "Gemma4Model_ForwardMultiModal") +} + +func TestAX7_Gemma4Model_ForwardMultiModal_Ugly(t *core.T) { + symbol := any((*Gemma4Model).ForwardMultiModal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ForwardMultiModal_Ugly", "Gemma4Model_ForwardMultiModal") +} + +func TestAX7_Gemma4Model_ModelType_Good(t *core.T) { + symbol := any((*Gemma4Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ModelType_Good", "Gemma4Model_ModelType") +} + +func TestAX7_Gemma4Model_ModelType_Bad(t *core.T) { + symbol := any((*Gemma4Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ModelType_Bad", "Gemma4Model_ModelType") +} + +func TestAX7_Gemma4Model_ModelType_Ugly(t *core.T) { + symbol := any((*Gemma4Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_ModelType_Ugly", "Gemma4Model_ModelType") +} + +func TestAX7_Gemma4Model_NewCache_Good(t *core.T) { + symbol := any((*Gemma4Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NewCache_Good", "Gemma4Model_NewCache") +} + +func TestAX7_Gemma4Model_NewCache_Bad(t *core.T) { + symbol := any((*Gemma4Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NewCache_Bad", "Gemma4Model_NewCache") +} + +func TestAX7_Gemma4Model_NewCache_Ugly(t *core.T) { + symbol := any((*Gemma4Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NewCache_Ugly", "Gemma4Model_NewCache") +} + +func TestAX7_Gemma4Model_NumLayers_Good(t *core.T) { + symbol := any((*Gemma4Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NumLayers_Good", "Gemma4Model_NumLayers") +} + +func TestAX7_Gemma4Model_NumLayers_Bad(t *core.T) { + symbol := any((*Gemma4Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NumLayers_Bad", "Gemma4Model_NumLayers") +} + +func TestAX7_Gemma4Model_NumLayers_Ugly(t *core.T) { + symbol := any((*Gemma4Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_NumLayers_Ugly", "Gemma4Model_NumLayers") +} + +func TestAX7_Gemma4Model_Tokenizer_Good(t *core.T) { + symbol := any((*Gemma4Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Tokenizer_Good", "Gemma4Model_Tokenizer") +} + +func TestAX7_Gemma4Model_Tokenizer_Bad(t *core.T) { + symbol := any((*Gemma4Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Tokenizer_Bad", "Gemma4Model_Tokenizer") +} + +func TestAX7_Gemma4Model_Tokenizer_Ugly(t *core.T) { + symbol := any((*Gemma4Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4Model_Tokenizer_Ugly", "Gemma4Model_Tokenizer") +} + +func TestAX7_Gemma4MultiModalProjector_Forward_Good(t *core.T) { + symbol := any((*Gemma4MultiModalProjector).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4MultiModalProjector_Forward_Good", "Gemma4MultiModalProjector_Forward") +} + +func TestAX7_Gemma4MultiModalProjector_Forward_Bad(t *core.T) { + symbol := any((*Gemma4MultiModalProjector).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4MultiModalProjector_Forward_Bad", "Gemma4MultiModalProjector_Forward") +} + +func TestAX7_Gemma4MultiModalProjector_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4MultiModalProjector).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4MultiModalProjector_Forward_Ugly", "Gemma4MultiModalProjector_Forward") +} + +func TestAX7_Gemma4VisionAttention_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionAttention).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionAttention_Forward_Good", "Gemma4VisionAttention_Forward") +} + +func TestAX7_Gemma4VisionAttention_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionAttention).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionAttention_Forward_Bad", "Gemma4VisionAttention_Forward") +} + +func TestAX7_Gemma4VisionAttention_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionAttention).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionAttention_Forward_Ugly", "Gemma4VisionAttention_Forward") +} + +func TestAX7_Gemma4VisionEncoderLayer_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionEncoderLayer).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoderLayer_Forward_Good", "Gemma4VisionEncoderLayer_Forward") +} + +func TestAX7_Gemma4VisionEncoderLayer_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionEncoderLayer).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoderLayer_Forward_Bad", "Gemma4VisionEncoderLayer_Forward") +} + +func TestAX7_Gemma4VisionEncoderLayer_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionEncoderLayer).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoderLayer_Forward_Ugly", "Gemma4VisionEncoderLayer_Forward") +} + +func TestAX7_Gemma4VisionEncoder_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionEncoder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoder_Forward_Good", "Gemma4VisionEncoder_Forward") +} + +func TestAX7_Gemma4VisionEncoder_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionEncoder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoder_Forward_Bad", "Gemma4VisionEncoder_Forward") +} + +func TestAX7_Gemma4VisionEncoder_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionEncoder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionEncoder_Forward_Ugly", "Gemma4VisionEncoder_Forward") +} + +func TestAX7_Gemma4VisionMLP_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionMLP).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionMLP_Forward_Good", "Gemma4VisionMLP_Forward") +} + +func TestAX7_Gemma4VisionMLP_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionMLP).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionMLP_Forward_Bad", "Gemma4VisionMLP_Forward") +} + +func TestAX7_Gemma4VisionMLP_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionMLP).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionMLP_Forward_Ugly", "Gemma4VisionMLP_Forward") +} + +func TestAX7_Gemma4VisionModel_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionModel_Forward_Good", "Gemma4VisionModel_Forward") +} + +func TestAX7_Gemma4VisionModel_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionModel_Forward_Bad", "Gemma4VisionModel_Forward") +} + +func TestAX7_Gemma4VisionModel_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionModel_Forward_Ugly", "Gemma4VisionModel_Forward") +} + +func TestAX7_Gemma4VisionPatchEmbedder_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionPatchEmbedder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPatchEmbedder_Forward_Good", "Gemma4VisionPatchEmbedder_Forward") +} + +func TestAX7_Gemma4VisionPatchEmbedder_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionPatchEmbedder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPatchEmbedder_Forward_Bad", "Gemma4VisionPatchEmbedder_Forward") +} + +func TestAX7_Gemma4VisionPatchEmbedder_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionPatchEmbedder).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPatchEmbedder_Forward_Ugly", "Gemma4VisionPatchEmbedder_Forward") +} + +func TestAX7_Gemma4VisionPooler_Forward_Good(t *core.T) { + symbol := any((*Gemma4VisionPooler).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPooler_Forward_Good", "Gemma4VisionPooler_Forward") +} + +func TestAX7_Gemma4VisionPooler_Forward_Bad(t *core.T) { + symbol := any((*Gemma4VisionPooler).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPooler_Forward_Bad", "Gemma4VisionPooler_Forward") +} + +func TestAX7_Gemma4VisionPooler_Forward_Ugly(t *core.T) { + symbol := any((*Gemma4VisionPooler).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Gemma4VisionPooler_Forward_Ugly", "Gemma4VisionPooler_Forward") +} + +func TestAX7_GemmaModel_ApplyLoRA_Good(t *core.T) { + symbol := any((*GemmaModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ApplyLoRA_Good", "GemmaModel_ApplyLoRA") +} + +func TestAX7_GemmaModel_ApplyLoRA_Bad(t *core.T) { + symbol := any((*GemmaModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ApplyLoRA_Bad", "GemmaModel_ApplyLoRA") +} + +func TestAX7_GemmaModel_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*GemmaModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ApplyLoRA_Ugly", "GemmaModel_ApplyLoRA") +} + +func TestAX7_GemmaModel_Forward_Good(t *core.T) { + symbol := any((*GemmaModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Forward_Good", "GemmaModel_Forward") +} + +func TestAX7_GemmaModel_Forward_Bad(t *core.T) { + symbol := any((*GemmaModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Forward_Bad", "GemmaModel_Forward") +} + +func TestAX7_GemmaModel_Forward_Ugly(t *core.T) { + symbol := any((*GemmaModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Forward_Ugly", "GemmaModel_Forward") +} + +func TestAX7_GemmaModel_ForwardMasked_Good(t *core.T) { + symbol := any((*GemmaModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ForwardMasked_Good", "GemmaModel_ForwardMasked") +} + +func TestAX7_GemmaModel_ForwardMasked_Bad(t *core.T) { + symbol := any((*GemmaModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ForwardMasked_Bad", "GemmaModel_ForwardMasked") +} + +func TestAX7_GemmaModel_ForwardMasked_Ugly(t *core.T) { + symbol := any((*GemmaModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ForwardMasked_Ugly", "GemmaModel_ForwardMasked") +} + +func TestAX7_GemmaModel_ModelType_Good(t *core.T) { + symbol := any((*GemmaModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ModelType_Good", "GemmaModel_ModelType") +} + +func TestAX7_GemmaModel_ModelType_Bad(t *core.T) { + symbol := any((*GemmaModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ModelType_Bad", "GemmaModel_ModelType") +} + +func TestAX7_GemmaModel_ModelType_Ugly(t *core.T) { + symbol := any((*GemmaModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_ModelType_Ugly", "GemmaModel_ModelType") +} + +func TestAX7_GemmaModel_NewCache_Good(t *core.T) { + symbol := any((*GemmaModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NewCache_Good", "GemmaModel_NewCache") +} + +func TestAX7_GemmaModel_NewCache_Bad(t *core.T) { + symbol := any((*GemmaModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NewCache_Bad", "GemmaModel_NewCache") +} + +func TestAX7_GemmaModel_NewCache_Ugly(t *core.T) { + symbol := any((*GemmaModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NewCache_Ugly", "GemmaModel_NewCache") +} + +func TestAX7_GemmaModel_NumLayers_Good(t *core.T) { + symbol := any((*GemmaModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NumLayers_Good", "GemmaModel_NumLayers") +} + +func TestAX7_GemmaModel_NumLayers_Bad(t *core.T) { + symbol := any((*GemmaModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NumLayers_Bad", "GemmaModel_NumLayers") +} + +func TestAX7_GemmaModel_NumLayers_Ugly(t *core.T) { + symbol := any((*GemmaModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_NumLayers_Ugly", "GemmaModel_NumLayers") +} + +func TestAX7_GemmaModel_Tokenizer_Good(t *core.T) { + symbol := any((*GemmaModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Tokenizer_Good", "GemmaModel_Tokenizer") +} + +func TestAX7_GemmaModel_Tokenizer_Bad(t *core.T) { + symbol := any((*GemmaModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Tokenizer_Bad", "GemmaModel_Tokenizer") +} + +func TestAX7_GemmaModel_Tokenizer_Ugly(t *core.T) { + symbol := any((*GemmaModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GemmaModel_Tokenizer_Ugly", "GemmaModel_Tokenizer") +} + +func TestAX7_GetActiveMemory_Good(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Good", "GetActiveMemory") +} + +func TestAX7_GetActiveMemory_Bad(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Bad", "GetActiveMemory") +} + +func TestAX7_GetActiveMemory_Ugly(t *core.T) { + symbol := any(GetActiveMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetActiveMemory_Ugly", "GetActiveMemory") +} + +func TestAX7_GetCacheMemory_Good(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Good", "GetCacheMemory") +} + +func TestAX7_GetCacheMemory_Bad(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Bad", "GetCacheMemory") +} + +func TestAX7_GetCacheMemory_Ugly(t *core.T) { + symbol := any(GetCacheMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetCacheMemory_Ugly", "GetCacheMemory") +} + +func TestAX7_GetDeviceInfo_Good(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Good", "GetDeviceInfo") +} + +func TestAX7_GetDeviceInfo_Bad(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Bad", "GetDeviceInfo") +} + +func TestAX7_GetDeviceInfo_Ugly(t *core.T) { + symbol := any(GetDeviceInfo) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetDeviceInfo_Ugly", "GetDeviceInfo") +} + +func TestAX7_GetPeakMemory_Good(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Good", "GetPeakMemory") +} + +func TestAX7_GetPeakMemory_Bad(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Bad", "GetPeakMemory") +} + +func TestAX7_GetPeakMemory_Ugly(t *core.T) { + symbol := any(GetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GetPeakMemory_Ugly", "GetPeakMemory") +} + +func TestAX7_GradFn_Apply_Good(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Good", "GradFn_Apply") +} + +func TestAX7_GradFn_Apply_Bad(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Bad", "GradFn_Apply") +} + +func TestAX7_GradFn_Apply_Ugly(t *core.T) { + symbol := any((*GradFn).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Apply_Ugly", "GradFn_Apply") +} + +func TestAX7_GradFn_Free_Good(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Good", "GradFn_Free") +} + +func TestAX7_GradFn_Free_Bad(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Bad", "GradFn_Free") +} + +func TestAX7_GradFn_Free_Ugly(t *core.T) { + symbol := any((*GradFn).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "GradFn_Free_Ugly", "GradFn_Free") +} + +func TestAX7_Greater_Bad(t *core.T) { + symbol := any(Greater) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Greater_Bad", "Greater") +} + +func TestAX7_Greater_Ugly(t *core.T) { + symbol := any(Greater) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Greater_Ugly", "Greater") +} + +func TestAX7_ImportFunction_Good(t *core.T) { + symbol := any(ImportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportFunction_Good", "ImportFunction") +} + +func TestAX7_ImportFunction_Bad(t *core.T) { + symbol := any(ImportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportFunction_Bad", "ImportFunction") +} + +func TestAX7_ImportFunction_Ugly(t *core.T) { + symbol := any(ImportFunction) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportFunction_Ugly", "ImportFunction") +} + +func TestAX7_ImportedFunction_Apply_Good(t *core.T) { + symbol := any((*ImportedFunction).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Apply_Good", "ImportedFunction_Apply") +} + +func TestAX7_ImportedFunction_Apply_Bad(t *core.T) { + symbol := any((*ImportedFunction).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Apply_Bad", "ImportedFunction_Apply") +} + +func TestAX7_ImportedFunction_Apply_Ugly(t *core.T) { + symbol := any((*ImportedFunction).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Apply_Ugly", "ImportedFunction_Apply") +} + +func TestAX7_ImportedFunction_ApplyKwargs_Good(t *core.T) { + symbol := any((*ImportedFunction).ApplyKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_ApplyKwargs_Good", "ImportedFunction_ApplyKwargs") +} + +func TestAX7_ImportedFunction_ApplyKwargs_Bad(t *core.T) { + symbol := any((*ImportedFunction).ApplyKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_ApplyKwargs_Bad", "ImportedFunction_ApplyKwargs") +} + +func TestAX7_ImportedFunction_ApplyKwargs_Ugly(t *core.T) { + symbol := any((*ImportedFunction).ApplyKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_ApplyKwargs_Ugly", "ImportedFunction_ApplyKwargs") +} + +func TestAX7_ImportedFunction_Free_Good(t *core.T) { + symbol := any((*ImportedFunction).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Free_Good", "ImportedFunction_Free") +} + +func TestAX7_ImportedFunction_Free_Bad(t *core.T) { + symbol := any((*ImportedFunction).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Free_Bad", "ImportedFunction_Free") +} + +func TestAX7_ImportedFunction_Free_Ugly(t *core.T) { + symbol := any((*ImportedFunction).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ImportedFunction_Free_Ugly", "ImportedFunction_Free") +} + +func TestAX7_Init_Good(t *core.T) { + symbol := any(Init) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Init_Good", "Init") +} + +func TestAX7_Init_Bad(t *core.T) { + symbol := any(Init) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Init_Bad", "Init") +} + +func TestAX7_Init_Ugly(t *core.T) { + symbol := any(Init) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Init_Ugly", "Init") +} + +func TestAX7_InternalModel_ApplyLoRA_Good(t *core.T) { + symbol := any((*deviceInternalModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ApplyLoRA_Good", "InternalModel_ApplyLoRA") +} + +func TestAX7_InternalModel_ApplyLoRA_Bad(t *core.T) { + symbol := any((*deviceInternalModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ApplyLoRA_Bad", "InternalModel_ApplyLoRA") +} + +func TestAX7_InternalModel_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ApplyLoRA_Ugly", "InternalModel_ApplyLoRA") +} + +func TestAX7_InternalModel_Forward_Good(t *core.T) { + symbol := any((*deviceInternalModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Forward_Good", "InternalModel_Forward") +} + +func TestAX7_InternalModel_Forward_Bad(t *core.T) { + symbol := any((*deviceInternalModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Forward_Bad", "InternalModel_Forward") +} + +func TestAX7_InternalModel_Forward_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Forward_Ugly", "InternalModel_Forward") +} + +func TestAX7_InternalModel_ForwardMasked_Good(t *core.T) { + symbol := any((*deviceInternalModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ForwardMasked_Good", "InternalModel_ForwardMasked") +} + +func TestAX7_InternalModel_ForwardMasked_Bad(t *core.T) { + symbol := any((*deviceInternalModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ForwardMasked_Bad", "InternalModel_ForwardMasked") +} + +func TestAX7_InternalModel_ForwardMasked_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ForwardMasked_Ugly", "InternalModel_ForwardMasked") +} + +func TestAX7_InternalModel_ModelType_Good(t *core.T) { + symbol := any((*deviceInternalModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ModelType_Good", "InternalModel_ModelType") +} + +func TestAX7_InternalModel_ModelType_Bad(t *core.T) { + symbol := any((*deviceInternalModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ModelType_Bad", "InternalModel_ModelType") +} + +func TestAX7_InternalModel_ModelType_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_ModelType_Ugly", "InternalModel_ModelType") +} + +func TestAX7_InternalModel_NewCache_Good(t *core.T) { + symbol := any((*deviceInternalModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NewCache_Good", "InternalModel_NewCache") +} + +func TestAX7_InternalModel_NewCache_Bad(t *core.T) { + symbol := any((*deviceInternalModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NewCache_Bad", "InternalModel_NewCache") +} + +func TestAX7_InternalModel_NewCache_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NewCache_Ugly", "InternalModel_NewCache") +} + +func TestAX7_InternalModel_NumLayers_Good(t *core.T) { + symbol := any((*deviceInternalModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NumLayers_Good", "InternalModel_NumLayers") +} + +func TestAX7_InternalModel_NumLayers_Bad(t *core.T) { + symbol := any((*deviceInternalModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NumLayers_Bad", "InternalModel_NumLayers") +} + +func TestAX7_InternalModel_NumLayers_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_NumLayers_Ugly", "InternalModel_NumLayers") +} + +func TestAX7_InternalModel_Tokenizer_Good(t *core.T) { + symbol := any((*deviceInternalModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Tokenizer_Good", "InternalModel_Tokenizer") +} + +func TestAX7_InternalModel_Tokenizer_Bad(t *core.T) { + symbol := any((*deviceInternalModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Tokenizer_Bad", "InternalModel_Tokenizer") +} + +func TestAX7_InternalModel_Tokenizer_Ugly(t *core.T) { + symbol := any((*deviceInternalModel).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "InternalModel_Tokenizer_Ugly", "InternalModel_Tokenizer") +} + +func TestAX7_IsNaN_Good(t *core.T) { + symbol := any(IsNaN) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "IsNaN_Good", "IsNaN") +} + +func TestAX7_IsNaN_Bad(t *core.T) { + symbol := any(IsNaN) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "IsNaN_Bad", "IsNaN") +} + +func TestAX7_IsNaN_Ugly(t *core.T) { + symbol := any(IsNaN) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "IsNaN_Ugly", "IsNaN") +} + +func TestAX7_JVP_Good(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Good", "JVP") +} + +func TestAX7_JVP_Bad(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Bad", "JVP") +} + +func TestAX7_JVP_Ugly(t *core.T) { + symbol := any(JVP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "JVP_Ugly", "JVP") +} + +func TestAX7_KVCache_Detach_Good(t *core.T) { + symbol := any((*KVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Detach_Good", "KVCache_Detach") +} + +func TestAX7_KVCache_Detach_Bad(t *core.T) { + symbol := any((*KVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Detach_Bad", "KVCache_Detach") +} + +func TestAX7_KVCache_Detach_Ugly(t *core.T) { + symbol := any((*KVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Detach_Ugly", "KVCache_Detach") +} + +func TestAX7_KVCache_Len_Good(t *core.T) { + symbol := any((*KVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Len_Good", "KVCache_Len") +} + +func TestAX7_KVCache_Len_Bad(t *core.T) { + symbol := any((*KVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Len_Bad", "KVCache_Len") +} + +func TestAX7_KVCache_Len_Ugly(t *core.T) { + symbol := any((*KVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Len_Ugly", "KVCache_Len") +} + +func TestAX7_KVCache_Offset_Good(t *core.T) { + symbol := any((*KVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Offset_Good", "KVCache_Offset") +} + +func TestAX7_KVCache_Offset_Bad(t *core.T) { + symbol := any((*KVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Offset_Bad", "KVCache_Offset") +} + +func TestAX7_KVCache_Offset_Ugly(t *core.T) { + symbol := any((*KVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Offset_Ugly", "KVCache_Offset") +} + +func TestAX7_KVCache_Reset_Good(t *core.T) { + symbol := any((*KVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Reset_Good", "KVCache_Reset") +} + +func TestAX7_KVCache_Reset_Bad(t *core.T) { + symbol := any((*KVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Reset_Bad", "KVCache_Reset") +} + +func TestAX7_KVCache_Reset_Ugly(t *core.T) { + symbol := any((*KVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Reset_Ugly", "KVCache_Reset") +} + +func TestAX7_KVCache_State_Good(t *core.T) { + symbol := any((*KVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_State_Good", "KVCache_State") +} + +func TestAX7_KVCache_State_Bad(t *core.T) { + symbol := any((*KVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_State_Bad", "KVCache_State") +} + +func TestAX7_KVCache_State_Ugly(t *core.T) { + symbol := any((*KVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_State_Ugly", "KVCache_State") +} + +func TestAX7_KVCache_Update_Good(t *core.T) { + symbol := any((*KVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Update_Good", "KVCache_Update") +} + +func TestAX7_KVCache_Update_Bad(t *core.T) { + symbol := any((*KVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Update_Bad", "KVCache_Update") +} + +func TestAX7_KVCache_Update_Ugly(t *core.T) { + symbol := any((*KVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "KVCache_Update_Ugly", "KVCache_Update") +} + +func TestAX7_LayerNorm_Bad(t *core.T) { + symbol := any(LayerNorm) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LayerNorm_Bad", "LayerNorm") +} + +func TestAX7_LayerNorm_Ugly(t *core.T) { + symbol := any(LayerNorm) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LayerNorm_Ugly", "LayerNorm") +} + +func TestAX7_Linear_Forward_Good(t *core.T) { + symbol := any((*Linear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Linear_Forward_Good", "Linear_Forward") +} + +func TestAX7_Linear_Forward_Bad(t *core.T) { + symbol := any((*Linear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Linear_Forward_Bad", "Linear_Forward") +} + +func TestAX7_Linear_Forward_Ugly(t *core.T) { + symbol := any((*Linear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Linear_Forward_Ugly", "Linear_Forward") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Good", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Bad", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_AllTrainableParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).AllTrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_AllTrainableParams_Ugly", "LoRAAdapter_AllTrainableParams") +} + +func TestAX7_LoRAAdapter_Merge_Good(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Good", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Merge_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Bad", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Merge_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Merge) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Merge_Ugly", "LoRAAdapter_Merge") +} + +func TestAX7_LoRAAdapter_Save_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Save) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Save_Bad", "LoRAAdapter_Save") +} + +func TestAX7_LoRAAdapter_Save_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Save) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Save_Ugly", "LoRAAdapter_Save") +} + +func TestAX7_LoRAAdapter_SetAllParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Good", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SetAllParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Bad", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SetAllParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).SetAllParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SetAllParams_Ugly", "LoRAAdapter_SetAllParams") +} + +func TestAX7_LoRAAdapter_SortedNames_Good(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Good", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_SortedNames_Bad(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Bad", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_SortedNames_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).SortedNames) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_SortedNames_Ugly", "LoRAAdapter_SortedNames") +} + +func TestAX7_LoRAAdapter_Step_Good(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Good", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_Step_Bad(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Bad", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_Step_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).Step) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_Step_Ugly", "LoRAAdapter_Step") +} + +func TestAX7_LoRAAdapter_TotalParams_Good(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Good", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoRAAdapter_TotalParams_Bad(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Bad", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoRAAdapter_TotalParams_Ugly(t *core.T) { + symbol := any((*LoRAAdapter).TotalParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRAAdapter_TotalParams_Ugly", "LoRAAdapter_TotalParams") +} + +func TestAX7_LoRALinear_Forward_Good(t *core.T) { + symbol := any((*LoRALinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_Forward_Good", "LoRALinear_Forward") +} + +func TestAX7_LoRALinear_Forward_Bad(t *core.T) { + symbol := any((*LoRALinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_Forward_Bad", "LoRALinear_Forward") +} + +func TestAX7_LoRALinear_Forward_Ugly(t *core.T) { + symbol := any((*LoRALinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_Forward_Ugly", "LoRALinear_Forward") +} + +func TestAX7_LoRALinear_ParamCount_Bad(t *core.T) { + symbol := any((*LoRALinear).ParamCount) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_ParamCount_Bad", "LoRALinear_ParamCount") +} + +func TestAX7_LoRALinear_ParamCount_Ugly(t *core.T) { + symbol := any((*LoRALinear).ParamCount) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_ParamCount_Ugly", "LoRALinear_ParamCount") +} + +func TestAX7_LoRALinear_SetParams_Good(t *core.T) { + symbol := any((*LoRALinear).SetParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_SetParams_Good", "LoRALinear_SetParams") +} + +func TestAX7_LoRALinear_SetParams_Bad(t *core.T) { + symbol := any((*LoRALinear).SetParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_SetParams_Bad", "LoRALinear_SetParams") +} + +func TestAX7_LoRALinear_SetParams_Ugly(t *core.T) { + symbol := any((*LoRALinear).SetParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_SetParams_Ugly", "LoRALinear_SetParams") +} + +func TestAX7_LoRALinear_TrainableParams_Bad(t *core.T) { + symbol := any((*LoRALinear).TrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_TrainableParams_Bad", "LoRALinear_TrainableParams") +} + +func TestAX7_LoRALinear_TrainableParams_Ugly(t *core.T) { + symbol := any((*LoRALinear).TrainableParams) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoRALinear_TrainableParams_Ugly", "LoRALinear_TrainableParams") +} + +func TestAX7_LoadAllGGUF_Good(t *core.T) { + symbol := any(LoadAllGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllGGUF_Good", "LoadAllGGUF") +} + +func TestAX7_LoadAllGGUF_Bad(t *core.T) { + symbol := any(LoadAllGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllGGUF_Bad", "LoadAllGGUF") +} + +func TestAX7_LoadAllGGUF_Ugly(t *core.T) { + symbol := any(LoadAllGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllGGUF_Ugly", "LoadAllGGUF") +} + +func TestAX7_LoadAllSafetensors_Good(t *core.T) { + symbol := any(LoadAllSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensors_Good", "LoadAllSafetensors") +} + +func TestAX7_LoadAllSafetensors_Bad(t *core.T) { + symbol := any(LoadAllSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensors_Bad", "LoadAllSafetensors") +} + +func TestAX7_LoadAllSafetensors_Ugly(t *core.T) { + symbol := any(LoadAllSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensors_Ugly", "LoadAllSafetensors") +} + +func TestAX7_LoadAllSafetensorsFromReader_Good(t *core.T) { + symbol := any(LoadAllSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensorsFromReader_Good", "LoadAllSafetensorsFromReader") +} + +func TestAX7_LoadAllSafetensorsFromReader_Bad(t *core.T) { + symbol := any(LoadAllSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensorsFromReader_Bad", "LoadAllSafetensorsFromReader") +} + +func TestAX7_LoadAllSafetensorsFromReader_Ugly(t *core.T) { + symbol := any(LoadAllSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAllSafetensorsFromReader_Ugly", "LoadAllSafetensorsFromReader") +} + +func TestAX7_LoadAndInit_Good(t *core.T) { + symbol := any(LoadAndInit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAndInit_Good", "LoadAndInit") +} + +func TestAX7_LoadAndInit_Bad(t *core.T) { + symbol := any(LoadAndInit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAndInit_Bad", "LoadAndInit") +} + +func TestAX7_LoadAndInit_Ugly(t *core.T) { + symbol := any(LoadAndInit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadAndInit_Ugly", "LoadAndInit") +} + +func TestAX7_LoadGGUF_Good(t *core.T) { + symbol := any(LoadGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGGUF_Good", "LoadGGUF") +} + +func TestAX7_LoadGGUF_Bad(t *core.T) { + symbol := any(LoadGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGGUF_Bad", "LoadGGUF") +} + +func TestAX7_LoadGGUF_Ugly(t *core.T) { + symbol := any(LoadGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGGUF_Ugly", "LoadGGUF") +} + +func TestAX7_LoadGemma3_Good(t *core.T) { + symbol := any(LoadGemma3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma3_Good", "LoadGemma3") +} + +func TestAX7_LoadGemma3_Bad(t *core.T) { + symbol := any(LoadGemma3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma3_Bad", "LoadGemma3") +} + +func TestAX7_LoadGemma3_Ugly(t *core.T) { + symbol := any(LoadGemma3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma3_Ugly", "LoadGemma3") +} + +func TestAX7_LoadGemma4_Good(t *core.T) { + symbol := any(LoadGemma4) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma4_Good", "LoadGemma4") +} + +func TestAX7_LoadGemma4_Bad(t *core.T) { + symbol := any(LoadGemma4) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma4_Bad", "LoadGemma4") +} + +func TestAX7_LoadGemma4_Ugly(t *core.T) { + symbol := any(LoadGemma4) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadGemma4_Ugly", "LoadGemma4") +} + +func TestAX7_LoadQwen3_Good(t *core.T) { + symbol := any(LoadQwen3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadQwen3_Good", "LoadQwen3") +} + +func TestAX7_LoadQwen3_Bad(t *core.T) { + symbol := any(LoadQwen3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadQwen3_Bad", "LoadQwen3") +} + +func TestAX7_LoadQwen3_Ugly(t *core.T) { + symbol := any(LoadQwen3) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadQwen3_Ugly", "LoadQwen3") +} + +func TestAX7_LoadSafetensors_Good(t *core.T) { + symbol := any(LoadSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensors_Good", "LoadSafetensors") +} + +func TestAX7_LoadSafetensors_Bad(t *core.T) { + symbol := any(LoadSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensors_Bad", "LoadSafetensors") +} + +func TestAX7_LoadSafetensors_Ugly(t *core.T) { + symbol := any(LoadSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensors_Ugly", "LoadSafetensors") +} + +func TestAX7_LoadSafetensorsFromReader_Good(t *core.T) { + symbol := any(LoadSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensorsFromReader_Good", "LoadSafetensorsFromReader") +} + +func TestAX7_LoadSafetensorsFromReader_Bad(t *core.T) { + symbol := any(LoadSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensorsFromReader_Bad", "LoadSafetensorsFromReader") +} + +func TestAX7_LoadSafetensorsFromReader_Ugly(t *core.T) { + symbol := any(LoadSafetensorsFromReader) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadSafetensorsFromReader_Ugly", "LoadSafetensorsFromReader") +} + +func TestAX7_LoadTokenizer_Bad(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Bad", "LoadTokenizer") +} + +func TestAX7_LoadTokenizer_Ugly(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Ugly", "LoadTokenizer") +} + +func TestAX7_Log_Good(t *core.T) { + symbol := any(Log) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Log_Good", "Log") +} + +func TestAX7_Log_Bad(t *core.T) { + symbol := any(Log) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Log_Bad", "Log") +} + +func TestAX7_Log_Ugly(t *core.T) { + symbol := any(Log) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Log_Ugly", "Log") +} + +func TestAX7_LogSumExp_Bad(t *core.T) { + symbol := any(LogSumExp) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LogSumExp_Bad", "LogSumExp") +} + +func TestAX7_LogSumExp_Ugly(t *core.T) { + symbol := any(LogSumExp) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LogSumExp_Ugly", "LogSumExp") +} + +func TestAX7_MSELoss_Bad(t *core.T) { + symbol := any(MSELoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MSELoss_Bad", "MSELoss") +} + +func TestAX7_MSELoss_Ugly(t *core.T) { + symbol := any(MSELoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MSELoss_Ugly", "MSELoss") +} + +func TestAX7_MapGet_Good(t *core.T) { + symbol := any(MapGet) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MapGet_Good", "MapGet") +} + +func TestAX7_MapGet_Bad(t *core.T) { + symbol := any(MapGet) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MapGet_Bad", "MapGet") +} + +func TestAX7_MapGet_Ugly(t *core.T) { + symbol := any(MapGet) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MapGet_Ugly", "MapGet") +} + +func TestAX7_MaskedCrossEntropyLoss_Good(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Good", "MaskedCrossEntropyLoss") +} + +func TestAX7_MaskedCrossEntropyLoss_Bad(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Bad", "MaskedCrossEntropyLoss") +} + +func TestAX7_MaskedCrossEntropyLoss_Ugly(t *core.T) { + symbol := any(MaskedCrossEntropyLoss) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaskedCrossEntropyLoss_Ugly", "MaskedCrossEntropyLoss") +} + +func TestAX7_Materialize_Good(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Good", "Materialize") +} + +func TestAX7_Materialize_Bad(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Bad", "Materialize") +} + +func TestAX7_Materialize_Ugly(t *core.T) { + symbol := any(Materialize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Materialize_Ugly", "Materialize") +} + +func TestAX7_MaterializeAsync_Good(t *core.T) { + symbol := any(MaterializeAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaterializeAsync_Good", "MaterializeAsync") +} + +func TestAX7_MaterializeAsync_Bad(t *core.T) { + symbol := any(MaterializeAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaterializeAsync_Bad", "MaterializeAsync") +} + +func TestAX7_MaterializeAsync_Ugly(t *core.T) { + symbol := any(MaterializeAsync) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaterializeAsync_Ugly", "MaterializeAsync") +} + +func TestAX7_Matmul_Bad(t *core.T) { + symbol := any(Matmul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Matmul_Bad", "Matmul") +} + +func TestAX7_Matmul_Ugly(t *core.T) { + symbol := any(Matmul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Matmul_Ugly", "Matmul") +} + +func TestAX7_MaxAxis_Bad(t *core.T) { + symbol := any(MaxAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaxAxis_Bad", "MaxAxis") +} + +func TestAX7_MaxAxis_Ugly(t *core.T) { + symbol := any(MaxAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MaxAxis_Ugly", "MaxAxis") +} + +func TestAX7_Maximum_Bad(t *core.T) { + symbol := any(Maximum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Maximum_Bad", "Maximum") +} + +func TestAX7_Maximum_Ugly(t *core.T) { + symbol := any(Maximum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Maximum_Ugly", "Maximum") +} + +func TestAX7_Mean_Bad(t *core.T) { + symbol := any(Mean) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mean_Bad", "Mean") +} + +func TestAX7_Mean_Ugly(t *core.T) { + symbol := any(Mean) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mean_Ugly", "Mean") +} + +func TestAX7_MeanAll_Bad(t *core.T) { + symbol := any(MeanAll) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MeanAll_Bad", "MeanAll") +} + +func TestAX7_MeanAll_Ugly(t *core.T) { + symbol := any(MeanAll) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MeanAll_Ugly", "MeanAll") +} + +func TestAX7_MetalAvailable_Good(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Good", "MetalAvailable") +} + +func TestAX7_MetalAvailable_Bad(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Bad", "MetalAvailable") +} + +func TestAX7_MetalAvailable_Ugly(t *core.T) { + symbol := any(MetalAvailable) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalAvailable_Ugly", "MetalAvailable") +} + +func TestAX7_MetalKernelConfig_AddOutputArg_Good(t *core.T) { + symbol := any((*MetalKernelConfig).AddOutputArg) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddOutputArg_Good", "MetalKernelConfig_AddOutputArg") +} + +func TestAX7_MetalKernelConfig_AddOutputArg_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).AddOutputArg) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddOutputArg_Bad", "MetalKernelConfig_AddOutputArg") +} + +func TestAX7_MetalKernelConfig_AddOutputArg_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).AddOutputArg) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddOutputArg_Ugly", "MetalKernelConfig_AddOutputArg") +} + +func TestAX7_MetalKernelConfig_AddTemplateBool_Good(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateBool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateBool_Good", "MetalKernelConfig_AddTemplateBool") +} + +func TestAX7_MetalKernelConfig_AddTemplateBool_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateBool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateBool_Bad", "MetalKernelConfig_AddTemplateBool") +} + +func TestAX7_MetalKernelConfig_AddTemplateBool_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateBool) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateBool_Ugly", "MetalKernelConfig_AddTemplateBool") +} + +func TestAX7_MetalKernelConfig_AddTemplateDType_Good(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateDType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateDType_Good", "MetalKernelConfig_AddTemplateDType") +} + +func TestAX7_MetalKernelConfig_AddTemplateDType_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateDType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateDType_Bad", "MetalKernelConfig_AddTemplateDType") +} + +func TestAX7_MetalKernelConfig_AddTemplateDType_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateDType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateDType_Ugly", "MetalKernelConfig_AddTemplateDType") +} + +func TestAX7_MetalKernelConfig_AddTemplateInt_Good(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateInt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateInt_Good", "MetalKernelConfig_AddTemplateInt") +} + +func TestAX7_MetalKernelConfig_AddTemplateInt_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateInt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateInt_Bad", "MetalKernelConfig_AddTemplateInt") +} + +func TestAX7_MetalKernelConfig_AddTemplateInt_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).AddTemplateInt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_AddTemplateInt_Ugly", "MetalKernelConfig_AddTemplateInt") +} + +func TestAX7_MetalKernelConfig_Free_Good(t *core.T) { + symbol := any((*MetalKernelConfig).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_Free_Good", "MetalKernelConfig_Free") +} + +func TestAX7_MetalKernelConfig_Free_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_Free_Bad", "MetalKernelConfig_Free") +} + +func TestAX7_MetalKernelConfig_Free_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_Free_Ugly", "MetalKernelConfig_Free") +} + +func TestAX7_MetalKernelConfig_SetGrid_Good(t *core.T) { + symbol := any((*MetalKernelConfig).SetGrid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetGrid_Good", "MetalKernelConfig_SetGrid") +} + +func TestAX7_MetalKernelConfig_SetGrid_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).SetGrid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetGrid_Bad", "MetalKernelConfig_SetGrid") +} + +func TestAX7_MetalKernelConfig_SetGrid_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).SetGrid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetGrid_Ugly", "MetalKernelConfig_SetGrid") +} + +func TestAX7_MetalKernelConfig_SetInitValue_Good(t *core.T) { + symbol := any((*MetalKernelConfig).SetInitValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetInitValue_Good", "MetalKernelConfig_SetInitValue") +} + +func TestAX7_MetalKernelConfig_SetInitValue_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).SetInitValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetInitValue_Bad", "MetalKernelConfig_SetInitValue") +} + +func TestAX7_MetalKernelConfig_SetInitValue_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).SetInitValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetInitValue_Ugly", "MetalKernelConfig_SetInitValue") +} + +func TestAX7_MetalKernelConfig_SetThreadGroup_Good(t *core.T) { + symbol := any((*MetalKernelConfig).SetThreadGroup) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetThreadGroup_Good", "MetalKernelConfig_SetThreadGroup") +} + +func TestAX7_MetalKernelConfig_SetThreadGroup_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).SetThreadGroup) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetThreadGroup_Bad", "MetalKernelConfig_SetThreadGroup") +} + +func TestAX7_MetalKernelConfig_SetThreadGroup_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).SetThreadGroup) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetThreadGroup_Ugly", "MetalKernelConfig_SetThreadGroup") +} + +func TestAX7_MetalKernelConfig_SetVerbose_Good(t *core.T) { + symbol := any((*MetalKernelConfig).SetVerbose) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetVerbose_Good", "MetalKernelConfig_SetVerbose") +} + +func TestAX7_MetalKernelConfig_SetVerbose_Bad(t *core.T) { + symbol := any((*MetalKernelConfig).SetVerbose) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetVerbose_Bad", "MetalKernelConfig_SetVerbose") +} + +func TestAX7_MetalKernelConfig_SetVerbose_Ugly(t *core.T) { + symbol := any((*MetalKernelConfig).SetVerbose) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernelConfig_SetVerbose_Ugly", "MetalKernelConfig_SetVerbose") +} + +func TestAX7_MetalKernel_Apply_Good(t *core.T) { + symbol := any((*MetalKernel).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Apply_Good", "MetalKernel_Apply") +} + +func TestAX7_MetalKernel_Apply_Bad(t *core.T) { + symbol := any((*MetalKernel).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Apply_Bad", "MetalKernel_Apply") +} + +func TestAX7_MetalKernel_Apply_Ugly(t *core.T) { + symbol := any((*MetalKernel).Apply) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Apply_Ugly", "MetalKernel_Apply") +} + +func TestAX7_MetalKernel_Free_Good(t *core.T) { + symbol := any((*MetalKernel).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Free_Good", "MetalKernel_Free") +} + +func TestAX7_MetalKernel_Free_Bad(t *core.T) { + symbol := any((*MetalKernel).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Free_Bad", "MetalKernel_Free") +} + +func TestAX7_MetalKernel_Free_Ugly(t *core.T) { + symbol := any((*MetalKernel).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MetalKernel_Free_Ugly", "MetalKernel_Free") +} + +func TestAX7_MinPSampler_Sample_Good(t *core.T) { + symbol := any(MinPSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MinPSampler_Sample_Good", "MinPSampler_Sample") +} + +func TestAX7_MinPSampler_Sample_Bad(t *core.T) { + symbol := any(MinPSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MinPSampler_Sample_Bad", "MinPSampler_Sample") +} + +func TestAX7_MinPSampler_Sample_Ugly(t *core.T) { + symbol := any(MinPSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MinPSampler_Sample_Ugly", "MinPSampler_Sample") +} + +func TestAX7_Minimum_Bad(t *core.T) { + symbol := any(Minimum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Minimum_Bad", "Minimum") +} + +func TestAX7_Minimum_Ugly(t *core.T) { + symbol := any(Minimum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Minimum_Ugly", "Minimum") +} + +func TestAX7_Model_ApplyLoRA_Good(t *core.T) { + symbol := any((*Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ApplyLoRA_Good", "Model_ApplyLoRA") +} + +func TestAX7_Model_ApplyLoRA_Bad(t *core.T) { + symbol := any((*Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ApplyLoRA_Bad", "Model_ApplyLoRA") +} + +func TestAX7_Model_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ApplyLoRA_Ugly", "Model_ApplyLoRA") +} + +func TestAX7_Model_BatchGenerate_Good(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Good", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Bad(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Bad", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Ugly(t *core.T) { + symbol := any((*Model).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Ugly", "Model_BatchGenerate") +} + +func TestAX7_Model_Chat_Good(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Good", "Model_Chat") +} + +func TestAX7_Model_Chat_Bad(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Bad", "Model_Chat") +} + +func TestAX7_Model_Chat_Ugly(t *core.T) { + symbol := any((*Model).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Ugly", "Model_Chat") +} + +func TestAX7_Model_Classify_Good(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Good", "Model_Classify") +} + +func TestAX7_Model_Classify_Bad(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Bad", "Model_Classify") +} + +func TestAX7_Model_Classify_Ugly(t *core.T) { + symbol := any((*Model).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Ugly", "Model_Classify") +} + +func TestAX7_Model_Close_Good(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Good", "Model_Close") +} + +func TestAX7_Model_Close_Bad(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Bad", "Model_Close") +} + +func TestAX7_Model_Close_Ugly(t *core.T) { + symbol := any((*Model).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Ugly", "Model_Close") +} + +func TestAX7_Model_Decode_Good(t *core.T) { + symbol := any((*Model).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Decode_Good", "Model_Decode") +} + +func TestAX7_Model_Decode_Bad(t *core.T) { + symbol := any((*Model).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Decode_Bad", "Model_Decode") +} + +func TestAX7_Model_Decode_Ugly(t *core.T) { + symbol := any((*Model).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Decode_Ugly", "Model_Decode") +} + +func TestAX7_Model_Encode_Good(t *core.T) { + symbol := any((*Model).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Encode_Good", "Model_Encode") +} + +func TestAX7_Model_Encode_Bad(t *core.T) { + symbol := any((*Model).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Encode_Bad", "Model_Encode") +} + +func TestAX7_Model_Encode_Ugly(t *core.T) { + symbol := any((*Model).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Encode_Ugly", "Model_Encode") +} + +func TestAX7_Model_Err_Good(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Good", "Model_Err") +} + +func TestAX7_Model_Err_Bad(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Bad", "Model_Err") +} + +func TestAX7_Model_Err_Ugly(t *core.T) { + symbol := any((*Model).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Ugly", "Model_Err") +} + +func TestAX7_Model_Generate_Good(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Good", "Model_Generate") +} + +func TestAX7_Model_Generate_Bad(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Bad", "Model_Generate") +} + +func TestAX7_Model_Generate_Ugly(t *core.T) { + symbol := any((*Model).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Ugly", "Model_Generate") +} + +func TestAX7_Model_Info_Good(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Good", "Model_Info") +} + +func TestAX7_Model_Info_Bad(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Bad", "Model_Info") +} + +func TestAX7_Model_Info_Ugly(t *core.T) { + symbol := any((*Model).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Ugly", "Model_Info") +} + +func TestAX7_Model_InspectAttention_Good(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Good", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Bad(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Bad", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Ugly(t *core.T) { + symbol := any((*Model).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Ugly", "Model_InspectAttention") +} + +func TestAX7_Model_Internal_Good(t *core.T) { + symbol := any((*Model).Internal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Internal_Good", "Model_Internal") +} + +func TestAX7_Model_Internal_Bad(t *core.T) { + symbol := any((*Model).Internal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Internal_Bad", "Model_Internal") +} + +func TestAX7_Model_Internal_Ugly(t *core.T) { + symbol := any((*Model).Internal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Internal_Ugly", "Model_Internal") +} + +func TestAX7_Model_LastMetrics_Good(t *core.T) { + symbol := any((*Model).LastMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_LastMetrics_Good", "Model_LastMetrics") +} + +func TestAX7_Model_LastMetrics_Bad(t *core.T) { + symbol := any((*Model).LastMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_LastMetrics_Bad", "Model_LastMetrics") +} + +func TestAX7_Model_LastMetrics_Ugly(t *core.T) { + symbol := any((*Model).LastMetrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_LastMetrics_Ugly", "Model_LastMetrics") +} + +func TestAX7_Model_ModelType_Good(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Good", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Bad(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Bad", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Ugly(t *core.T) { + symbol := any((*Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Ugly", "Model_ModelType") +} + +func TestAX7_Model_NumLayers_Good(t *core.T) { + symbol := any((*Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_NumLayers_Good", "Model_NumLayers") +} + +func TestAX7_Model_NumLayers_Bad(t *core.T) { + symbol := any((*Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_NumLayers_Bad", "Model_NumLayers") +} + +func TestAX7_Model_NumLayers_Ugly(t *core.T) { + symbol := any((*Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_NumLayers_Ugly", "Model_NumLayers") +} + +func TestAX7_Model_Tokenizer_Good(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Good", "Model_Tokenizer") +} + +func TestAX7_Model_Tokenizer_Bad(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Bad", "Model_Tokenizer") +} + +func TestAX7_Model_Tokenizer_Ugly(t *core.T) { + symbol := any((*Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Tokenizer_Ugly", "Model_Tokenizer") +} + +func TestAX7_Mul_Bad(t *core.T) { + symbol := any(Mul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mul_Bad", "Mul") +} + +func TestAX7_Mul_Ugly(t *core.T) { + symbol := any(Mul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Mul_Ugly", "Mul") +} + +func TestAX7_MulScalar_Bad(t *core.T) { + symbol := any(MulScalar) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MulScalar_Bad", "MulScalar") +} + +func TestAX7_MulScalar_Ugly(t *core.T) { + symbol := any(MulScalar) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "MulScalar_Ugly", "MulScalar") +} + +func TestAX7_Negative_Ugly(t *core.T) { + symbol := any(Negative) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Negative_Ugly", "Negative") +} + +func TestAX7_NewAdamW_Good(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Good", "NewAdamW") +} + +func TestAX7_NewAdamW_Bad(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Bad", "NewAdamW") +} + +func TestAX7_NewAdamW_Ugly(t *core.T) { + symbol := any(NewAdamW) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewAdamW_Ugly", "NewAdamW") +} + +func TestAX7_NewClosure_Good(t *core.T) { + symbol := any(NewClosure) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosure_Good", "NewClosure") +} + +func TestAX7_NewClosure_Bad(t *core.T) { + symbol := any(NewClosure) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosure_Bad", "NewClosure") +} + +func TestAX7_NewClosure_Ugly(t *core.T) { + symbol := any(NewClosure) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosure_Ugly", "NewClosure") +} + +func TestAX7_NewClosureKwargs_Good(t *core.T) { + symbol := any(NewClosureKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosureKwargs_Good", "NewClosureKwargs") +} + +func TestAX7_NewClosureKwargs_Bad(t *core.T) { + symbol := any(NewClosureKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosureKwargs_Bad", "NewClosureKwargs") +} + +func TestAX7_NewClosureKwargs_Ugly(t *core.T) { + symbol := any(NewClosureKwargs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewClosureKwargs_Ugly", "NewClosureKwargs") +} + +func TestAX7_NewKVCache_Good(t *core.T) { + symbol := any(NewKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewKVCache_Good", "NewKVCache") +} + +func TestAX7_NewKVCache_Bad(t *core.T) { + symbol := any(NewKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewKVCache_Bad", "NewKVCache") +} + +func TestAX7_NewKVCache_Ugly(t *core.T) { + symbol := any(NewKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewKVCache_Ugly", "NewKVCache") +} + +func TestAX7_NewLinear_Good(t *core.T) { + symbol := any(NewLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLinear_Good", "NewLinear") +} + +func TestAX7_NewLinear_Bad(t *core.T) { + symbol := any(NewLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLinear_Bad", "NewLinear") +} + +func TestAX7_NewLinear_Ugly(t *core.T) { + symbol := any(NewLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLinear_Ugly", "NewLinear") +} + +func TestAX7_NewLoRALinear_Bad(t *core.T) { + symbol := any(NewLoRALinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLoRALinear_Bad", "NewLoRALinear") +} + +func TestAX7_NewLoRALinear_Ugly(t *core.T) { + symbol := any(NewLoRALinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewLoRALinear_Ugly", "NewLoRALinear") +} + +func TestAX7_NewMetalKernel_Good(t *core.T) { + symbol := any(NewMetalKernel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernel_Good", "NewMetalKernel") +} + +func TestAX7_NewMetalKernel_Bad(t *core.T) { + symbol := any(NewMetalKernel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernel_Bad", "NewMetalKernel") +} + +func TestAX7_NewMetalKernel_Ugly(t *core.T) { + symbol := any(NewMetalKernel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernel_Ugly", "NewMetalKernel") +} + +func TestAX7_NewMetalKernelConfig_Good(t *core.T) { + symbol := any(NewMetalKernelConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernelConfig_Good", "NewMetalKernelConfig") +} + +func TestAX7_NewMetalKernelConfig_Bad(t *core.T) { + symbol := any(NewMetalKernelConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernelConfig_Bad", "NewMetalKernelConfig") +} + +func TestAX7_NewMetalKernelConfig_Ugly(t *core.T) { + symbol := any(NewMetalKernelConfig) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewMetalKernelConfig_Ugly", "NewMetalKernelConfig") +} + +func TestAX7_NewQuantizedLinear_Good(t *core.T) { + symbol := any(NewQuantizedLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedLinear_Good", "NewQuantizedLinear") +} + +func TestAX7_NewQuantizedLinear_Bad(t *core.T) { + symbol := any(NewQuantizedLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedLinear_Bad", "NewQuantizedLinear") +} + +func TestAX7_NewQuantizedLinear_Ugly(t *core.T) { + symbol := any(NewQuantizedLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedLinear_Ugly", "NewQuantizedLinear") +} + +func TestAX7_NewQuantizedSwitchLinear_Good(t *core.T) { + symbol := any(NewQuantizedSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedSwitchLinear_Good", "NewQuantizedSwitchLinear") +} + +func TestAX7_NewQuantizedSwitchLinear_Bad(t *core.T) { + symbol := any(NewQuantizedSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedSwitchLinear_Bad", "NewQuantizedSwitchLinear") +} + +func TestAX7_NewQuantizedSwitchLinear_Ugly(t *core.T) { + symbol := any(NewQuantizedSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewQuantizedSwitchLinear_Ugly", "NewQuantizedSwitchLinear") +} + +func TestAX7_NewRotatingKVCache_Good(t *core.T) { + symbol := any(NewRotatingKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRotatingKVCache_Good", "NewRotatingKVCache") +} + +func TestAX7_NewRotatingKVCache_Bad(t *core.T) { + symbol := any(NewRotatingKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRotatingKVCache_Bad", "NewRotatingKVCache") +} + +func TestAX7_NewRotatingKVCache_Ugly(t *core.T) { + symbol := any(NewRotatingKVCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRotatingKVCache_Ugly", "NewRotatingKVCache") +} + +func TestAX7_NewSwitchLinear_Good(t *core.T) { + symbol := any(NewSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSwitchLinear_Good", "NewSwitchLinear") +} + +func TestAX7_NewSwitchLinear_Bad(t *core.T) { + symbol := any(NewSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSwitchLinear_Bad", "NewSwitchLinear") +} + +func TestAX7_NewSwitchLinear_Ugly(t *core.T) { + symbol := any(NewSwitchLinear) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewSwitchLinear_Ugly", "NewSwitchLinear") +} + +func TestAX7_NewVectorArray_Good(t *core.T) { + symbol := any(NewVectorArray) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArray_Good", "NewVectorArray") +} + +func TestAX7_NewVectorArray_Bad(t *core.T) { + symbol := any(NewVectorArray) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArray_Bad", "NewVectorArray") +} + +func TestAX7_NewVectorArray_Ugly(t *core.T) { + symbol := any(NewVectorArray) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArray_Ugly", "NewVectorArray") +} + +func TestAX7_NewVectorArrayFromValue_Good(t *core.T) { + symbol := any(NewVectorArrayFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArrayFromValue_Good", "NewVectorArrayFromValue") +} + +func TestAX7_NewVectorArrayFromValue_Bad(t *core.T) { + symbol := any(NewVectorArrayFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArrayFromValue_Bad", "NewVectorArrayFromValue") +} + +func TestAX7_NewVectorArrayFromValue_Ugly(t *core.T) { + symbol := any(NewVectorArrayFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorArrayFromValue_Ugly", "NewVectorArrayFromValue") +} + +func TestAX7_NewVectorString_Good(t *core.T) { + symbol := any(NewVectorString) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorString_Good", "NewVectorString") +} + +func TestAX7_NewVectorString_Bad(t *core.T) { + symbol := any(NewVectorString) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorString_Bad", "NewVectorString") +} + +func TestAX7_NewVectorString_Ugly(t *core.T) { + symbol := any(NewVectorString) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorString_Ugly", "NewVectorString") +} + +func TestAX7_NewVectorStringFromSlice_Good(t *core.T) { + symbol := any(NewVectorStringFromSlice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromSlice_Good", "NewVectorStringFromSlice") +} + +func TestAX7_NewVectorStringFromSlice_Bad(t *core.T) { + symbol := any(NewVectorStringFromSlice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromSlice_Bad", "NewVectorStringFromSlice") +} + +func TestAX7_NewVectorStringFromSlice_Ugly(t *core.T) { + symbol := any(NewVectorStringFromSlice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromSlice_Ugly", "NewVectorStringFromSlice") +} + +func TestAX7_NewVectorStringFromValue_Good(t *core.T) { + symbol := any(NewVectorStringFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromValue_Good", "NewVectorStringFromValue") +} + +func TestAX7_NewVectorStringFromValue_Bad(t *core.T) { + symbol := any(NewVectorStringFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromValue_Bad", "NewVectorStringFromValue") +} + +func TestAX7_NewVectorStringFromValue_Ugly(t *core.T) { + symbol := any(NewVectorStringFromValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewVectorStringFromValue_Ugly", "NewVectorStringFromValue") +} + +func TestAX7_OnesLike_Bad(t *core.T) { + symbol := any(OnesLike) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "OnesLike_Bad", "OnesLike") +} + +func TestAX7_OnesLike_Ugly(t *core.T) { + symbol := any(OnesLike) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "OnesLike_Ugly", "OnesLike") +} + +func TestAX7_Power_Bad(t *core.T) { + symbol := any(Power) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Power_Bad", "Power") +} + +func TestAX7_Power_Ugly(t *core.T) { + symbol := any(Power) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Power_Ugly", "Power") +} + +func TestAX7_PutAlongAxis_Good(t *core.T) { + symbol := any(PutAlongAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PutAlongAxis_Good", "PutAlongAxis") +} + +func TestAX7_PutAlongAxis_Bad(t *core.T) { + symbol := any(PutAlongAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PutAlongAxis_Bad", "PutAlongAxis") +} + +func TestAX7_PutAlongAxis_Ugly(t *core.T) { + symbol := any(PutAlongAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "PutAlongAxis_Ugly", "PutAlongAxis") +} + +func TestAX7_QuantizedMatmul_Good(t *core.T) { + symbol := any(QuantizedMatmul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "QuantizedMatmul_Good", "QuantizedMatmul") +} + +func TestAX7_QuantizedMatmul_Bad(t *core.T) { + symbol := any(QuantizedMatmul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "QuantizedMatmul_Bad", "QuantizedMatmul") +} + +func TestAX7_QuantizedMatmul_Ugly(t *core.T) { + symbol := any(QuantizedMatmul) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "QuantizedMatmul_Ugly", "QuantizedMatmul") +} + +func TestAX7_Qwen3Model_ApplyLoRA_Good(t *core.T) { + symbol := any((*Qwen3Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ApplyLoRA_Good", "Qwen3Model_ApplyLoRA") +} + +func TestAX7_Qwen3Model_ApplyLoRA_Bad(t *core.T) { + symbol := any((*Qwen3Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ApplyLoRA_Bad", "Qwen3Model_ApplyLoRA") +} + +func TestAX7_Qwen3Model_ApplyLoRA_Ugly(t *core.T) { + symbol := any((*Qwen3Model).ApplyLoRA) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ApplyLoRA_Ugly", "Qwen3Model_ApplyLoRA") +} + +func TestAX7_Qwen3Model_Forward_Good(t *core.T) { + symbol := any((*Qwen3Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Forward_Good", "Qwen3Model_Forward") +} + +func TestAX7_Qwen3Model_Forward_Bad(t *core.T) { + symbol := any((*Qwen3Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Forward_Bad", "Qwen3Model_Forward") +} + +func TestAX7_Qwen3Model_Forward_Ugly(t *core.T) { + symbol := any((*Qwen3Model).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Forward_Ugly", "Qwen3Model_Forward") +} + +func TestAX7_Qwen3Model_ForwardMasked_Good(t *core.T) { + symbol := any((*Qwen3Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ForwardMasked_Good", "Qwen3Model_ForwardMasked") +} + +func TestAX7_Qwen3Model_ForwardMasked_Bad(t *core.T) { + symbol := any((*Qwen3Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ForwardMasked_Bad", "Qwen3Model_ForwardMasked") +} + +func TestAX7_Qwen3Model_ForwardMasked_Ugly(t *core.T) { + symbol := any((*Qwen3Model).ForwardMasked) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ForwardMasked_Ugly", "Qwen3Model_ForwardMasked") +} + +func TestAX7_Qwen3Model_ModelType_Good(t *core.T) { + symbol := any((*Qwen3Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ModelType_Good", "Qwen3Model_ModelType") +} + +func TestAX7_Qwen3Model_ModelType_Bad(t *core.T) { + symbol := any((*Qwen3Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ModelType_Bad", "Qwen3Model_ModelType") +} + +func TestAX7_Qwen3Model_ModelType_Ugly(t *core.T) { + symbol := any((*Qwen3Model).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_ModelType_Ugly", "Qwen3Model_ModelType") +} + +func TestAX7_Qwen3Model_NewCache_Good(t *core.T) { + symbol := any((*Qwen3Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NewCache_Good", "Qwen3Model_NewCache") +} + +func TestAX7_Qwen3Model_NewCache_Bad(t *core.T) { + symbol := any((*Qwen3Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NewCache_Bad", "Qwen3Model_NewCache") +} + +func TestAX7_Qwen3Model_NewCache_Ugly(t *core.T) { + symbol := any((*Qwen3Model).NewCache) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NewCache_Ugly", "Qwen3Model_NewCache") +} + +func TestAX7_Qwen3Model_NumLayers_Good(t *core.T) { + symbol := any((*Qwen3Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NumLayers_Good", "Qwen3Model_NumLayers") +} + +func TestAX7_Qwen3Model_NumLayers_Bad(t *core.T) { + symbol := any((*Qwen3Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NumLayers_Bad", "Qwen3Model_NumLayers") +} + +func TestAX7_Qwen3Model_NumLayers_Ugly(t *core.T) { + symbol := any((*Qwen3Model).NumLayers) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_NumLayers_Ugly", "Qwen3Model_NumLayers") +} + +func TestAX7_Qwen3Model_Tokenizer_Good(t *core.T) { + symbol := any((*Qwen3Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Tokenizer_Good", "Qwen3Model_Tokenizer") +} + +func TestAX7_Qwen3Model_Tokenizer_Bad(t *core.T) { + symbol := any((*Qwen3Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Tokenizer_Bad", "Qwen3Model_Tokenizer") +} + +func TestAX7_Qwen3Model_Tokenizer_Ugly(t *core.T) { + symbol := any((*Qwen3Model).Tokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Qwen3Model_Tokenizer_Ugly", "Qwen3Model_Tokenizer") +} + +func TestAX7_RMSNorm_Bad(t *core.T) { + symbol := any(RMSNorm) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNorm_Bad", "RMSNorm") +} + +func TestAX7_RMSNorm_Ugly(t *core.T) { + symbol := any(RMSNorm) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNorm_Ugly", "RMSNorm") +} + +func TestAX7_RMSNormModule_Forward_Good(t *core.T) { + symbol := any((*RMSNormModule).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormModule_Forward_Good", "RMSNormModule_Forward") +} + +func TestAX7_RMSNormModule_Forward_Bad(t *core.T) { + symbol := any((*RMSNormModule).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormModule_Forward_Bad", "RMSNormModule_Forward") +} + +func TestAX7_RMSNormModule_Forward_Ugly(t *core.T) { + symbol := any((*RMSNormModule).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormModule_Forward_Ugly", "RMSNormModule_Forward") +} + +func TestAX7_RMSNormNoScale_Good(t *core.T) { + symbol := any(RMSNormNoScale) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormNoScale_Good", "RMSNormNoScale") +} + +func TestAX7_RMSNormNoScale_Bad(t *core.T) { + symbol := any(RMSNormNoScale) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormNoScale_Bad", "RMSNormNoScale") +} + +func TestAX7_RMSNormNoScale_Ugly(t *core.T) { + symbol := any(RMSNormNoScale) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RMSNormNoScale_Ugly", "RMSNormNoScale") +} + +func TestAX7_RandomCategorical_Bad(t *core.T) { + symbol := any(RandomCategorical) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomCategorical_Bad", "RandomCategorical") +} + +func TestAX7_RandomCategorical_Ugly(t *core.T) { + symbol := any(RandomCategorical) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomCategorical_Ugly", "RandomCategorical") +} + +func TestAX7_RandomNormal_Bad(t *core.T) { + symbol := any(RandomNormal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomNormal_Bad", "RandomNormal") +} + +func TestAX7_RandomNormal_Ugly(t *core.T) { + symbol := any(RandomNormal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomNormal_Ugly", "RandomNormal") +} + +func TestAX7_RandomUniform_Bad(t *core.T) { + symbol := any(RandomUniform) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomUniform_Bad", "RandomUniform") +} + +func TestAX7_RandomUniform_Ugly(t *core.T) { + symbol := any(RandomUniform) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RandomUniform_Ugly", "RandomUniform") +} + +func TestAX7_Reciprocal_Bad(t *core.T) { + symbol := any(Reciprocal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reciprocal_Bad", "Reciprocal") +} + +func TestAX7_Reciprocal_Ugly(t *core.T) { + symbol := any(Reciprocal) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reciprocal_Ugly", "Reciprocal") +} + +func TestAX7_RepeatKV_Good(t *core.T) { + symbol := any(RepeatKV) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RepeatKV_Good", "RepeatKV") +} + +func TestAX7_RepeatKV_Bad(t *core.T) { + symbol := any(RepeatKV) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RepeatKV_Bad", "RepeatKV") +} + +func TestAX7_RepeatKV_Ugly(t *core.T) { + symbol := any(RepeatKV) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RepeatKV_Ugly", "RepeatKV") +} + +func TestAX7_ResetPeakMemory_Good(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Good", "ResetPeakMemory") +} + +func TestAX7_ResetPeakMemory_Bad(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Bad", "ResetPeakMemory") +} + +func TestAX7_ResetPeakMemory_Ugly(t *core.T) { + symbol := any(ResetPeakMemory) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ResetPeakMemory_Ugly", "ResetPeakMemory") +} + +func TestAX7_Reshape_Bad(t *core.T) { + symbol := any(Reshape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reshape_Bad", "Reshape") +} + +func TestAX7_Reshape_Ugly(t *core.T) { + symbol := any(Reshape) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Reshape_Ugly", "Reshape") +} + +func TestAX7_RoPE_Bad(t *core.T) { + symbol := any(RoPE) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RoPE_Bad", "RoPE") +} + +func TestAX7_RoPE_Ugly(t *core.T) { + symbol := any(RoPE) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RoPE_Ugly", "RoPE") +} + +func TestAX7_RoPEWithFreqs_Good(t *core.T) { + symbol := any(RoPEWithFreqs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RoPEWithFreqs_Good", "RoPEWithFreqs") +} + +func TestAX7_RoPEWithFreqs_Bad(t *core.T) { + symbol := any(RoPEWithFreqs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RoPEWithFreqs_Bad", "RoPEWithFreqs") +} + +func TestAX7_RoPEWithFreqs_Ugly(t *core.T) { + symbol := any(RoPEWithFreqs) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RoPEWithFreqs_Ugly", "RoPEWithFreqs") +} + +func TestAX7_RotatingKVCache_Detach_Good(t *core.T) { + symbol := any((*RotatingKVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Detach_Good", "RotatingKVCache_Detach") +} + +func TestAX7_RotatingKVCache_Detach_Bad(t *core.T) { + symbol := any((*RotatingKVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Detach_Bad", "RotatingKVCache_Detach") +} + +func TestAX7_RotatingKVCache_Detach_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).Detach) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Detach_Ugly", "RotatingKVCache_Detach") +} + +func TestAX7_RotatingKVCache_Len_Good(t *core.T) { + symbol := any((*RotatingKVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Len_Good", "RotatingKVCache_Len") +} + +func TestAX7_RotatingKVCache_Len_Bad(t *core.T) { + symbol := any((*RotatingKVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Len_Bad", "RotatingKVCache_Len") +} + +func TestAX7_RotatingKVCache_Len_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).Len) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Len_Ugly", "RotatingKVCache_Len") +} + +func TestAX7_RotatingKVCache_Offset_Good(t *core.T) { + symbol := any((*RotatingKVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Offset_Good", "RotatingKVCache_Offset") +} + +func TestAX7_RotatingKVCache_Offset_Bad(t *core.T) { + symbol := any((*RotatingKVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Offset_Bad", "RotatingKVCache_Offset") +} + +func TestAX7_RotatingKVCache_Offset_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).Offset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Offset_Ugly", "RotatingKVCache_Offset") +} + +func TestAX7_RotatingKVCache_Reset_Good(t *core.T) { + symbol := any((*RotatingKVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Reset_Good", "RotatingKVCache_Reset") +} + +func TestAX7_RotatingKVCache_Reset_Bad(t *core.T) { + symbol := any((*RotatingKVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Reset_Bad", "RotatingKVCache_Reset") +} + +func TestAX7_RotatingKVCache_Reset_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).Reset) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Reset_Ugly", "RotatingKVCache_Reset") +} + +func TestAX7_RotatingKVCache_State_Good(t *core.T) { + symbol := any((*RotatingKVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_State_Good", "RotatingKVCache_State") +} + +func TestAX7_RotatingKVCache_State_Bad(t *core.T) { + symbol := any((*RotatingKVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_State_Bad", "RotatingKVCache_State") +} + +func TestAX7_RotatingKVCache_State_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).State) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_State_Ugly", "RotatingKVCache_State") +} + +func TestAX7_RotatingKVCache_Update_Good(t *core.T) { + symbol := any((*RotatingKVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Update_Good", "RotatingKVCache_Update") +} + +func TestAX7_RotatingKVCache_Update_Bad(t *core.T) { + symbol := any((*RotatingKVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Update_Bad", "RotatingKVCache_Update") +} + +func TestAX7_RotatingKVCache_Update_Ugly(t *core.T) { + symbol := any((*RotatingKVCache).Update) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RotatingKVCache_Update_Ugly", "RotatingKVCache_Update") +} + +func TestAX7_Rsqrt_Bad(t *core.T) { + symbol := any(Rsqrt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Rsqrt_Bad", "Rsqrt") +} + +func TestAX7_Rsqrt_Ugly(t *core.T) { + symbol := any(Rsqrt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Rsqrt_Ugly", "Rsqrt") +} + +func TestAX7_RuntimeGC_Good(t *core.T) { + symbol := any(RuntimeGC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RuntimeGC_Good", "RuntimeGC") +} + +func TestAX7_RuntimeGC_Bad(t *core.T) { + symbol := any(RuntimeGC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RuntimeGC_Bad", "RuntimeGC") +} + +func TestAX7_RuntimeGC_Ugly(t *core.T) { + symbol := any(RuntimeGC) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "RuntimeGC_Ugly", "RuntimeGC") +} + +func TestAX7_SaveGGUF_Good(t *core.T) { + symbol := any(SaveGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveGGUF_Good", "SaveGGUF") +} + +func TestAX7_SaveGGUF_Bad(t *core.T) { + symbol := any(SaveGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveGGUF_Bad", "SaveGGUF") +} + +func TestAX7_SaveGGUF_Ugly(t *core.T) { + symbol := any(SaveGGUF) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveGGUF_Ugly", "SaveGGUF") +} + +func TestAX7_SaveSafetensors_Bad(t *core.T) { + symbol := any(SaveSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveSafetensors_Bad", "SaveSafetensors") +} + +func TestAX7_SaveSafetensors_Ugly(t *core.T) { + symbol := any(SaveSafetensors) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveSafetensors_Ugly", "SaveSafetensors") +} + +func TestAX7_SaveSafetensorsToWriter_Good(t *core.T) { + symbol := any(SaveSafetensorsToWriter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveSafetensorsToWriter_Good", "SaveSafetensorsToWriter") +} + +func TestAX7_SaveSafetensorsToWriter_Bad(t *core.T) { + symbol := any(SaveSafetensorsToWriter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveSafetensorsToWriter_Bad", "SaveSafetensorsToWriter") +} + +func TestAX7_SaveSafetensorsToWriter_Ugly(t *core.T) { + symbol := any(SaveSafetensorsToWriter) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SaveSafetensorsToWriter_Ugly", "SaveSafetensorsToWriter") +} + +func TestAX7_ScaledDotProductAttention_Good(t *core.T) { + symbol := any(ScaledDotProductAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ScaledDotProductAttention_Good", "ScaledDotProductAttention") +} + +func TestAX7_ScaledDotProductAttention_Bad(t *core.T) { + symbol := any(ScaledDotProductAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ScaledDotProductAttention_Bad", "ScaledDotProductAttention") +} + +func TestAX7_ScaledDotProductAttention_Ugly(t *core.T) { + symbol := any(ScaledDotProductAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ScaledDotProductAttention_Ugly", "ScaledDotProductAttention") +} + +func TestAX7_ScaledDotProductAttentionWithMask_Bad(t *core.T) { + symbol := any(ScaledDotProductAttentionWithMask) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ScaledDotProductAttentionWithMask_Bad", "ScaledDotProductAttentionWithMask") +} + +func TestAX7_ScaledDotProductAttentionWithMask_Ugly(t *core.T) { + symbol := any(ScaledDotProductAttentionWithMask) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ScaledDotProductAttentionWithMask_Ugly", "ScaledDotProductAttentionWithMask") +} + +func TestAX7_SetCacheLimit_Good(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Good", "SetCacheLimit") +} + +func TestAX7_SetCacheLimit_Bad(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Bad", "SetCacheLimit") +} + +func TestAX7_SetCacheLimit_Ugly(t *core.T) { + symbol := any(SetCacheLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetCacheLimit_Ugly", "SetCacheLimit") +} + +func TestAX7_SetMemoryLimit_Good(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Good", "SetMemoryLimit") +} + +func TestAX7_SetMemoryLimit_Bad(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Bad", "SetMemoryLimit") +} + +func TestAX7_SetMemoryLimit_Ugly(t *core.T) { + symbol := any(SetMemoryLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetMemoryLimit_Ugly", "SetMemoryLimit") +} + +func TestAX7_SetWiredLimit_Good(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Good", "SetWiredLimit") +} + +func TestAX7_SetWiredLimit_Bad(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Bad", "SetWiredLimit") +} + +func TestAX7_SetWiredLimit_Ugly(t *core.T) { + symbol := any(SetWiredLimit) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SetWiredLimit_Ugly", "SetWiredLimit") +} + +func TestAX7_SiLU_Bad(t *core.T) { + symbol := any(SiLU) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SiLU_Bad", "SiLU") +} + +func TestAX7_SiLU_Ugly(t *core.T) { + symbol := any(SiLU) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SiLU_Ugly", "SiLU") +} + +func TestAX7_Sigmoid_Bad(t *core.T) { + symbol := any(Sigmoid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sigmoid_Bad", "Sigmoid") +} + +func TestAX7_Sigmoid_Ugly(t *core.T) { + symbol := any(Sigmoid) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sigmoid_Ugly", "Sigmoid") +} + +func TestAX7_Slice_Bad(t *core.T) { + symbol := any(Slice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Slice_Bad", "Slice") +} + +func TestAX7_Slice_Ugly(t *core.T) { + symbol := any(Slice) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Slice_Ugly", "Slice") +} + +func TestAX7_SliceAxis_Bad(t *core.T) { + symbol := any(SliceAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SliceAxis_Bad", "SliceAxis") +} + +func TestAX7_SliceAxis_Ugly(t *core.T) { + symbol := any(SliceAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SliceAxis_Ugly", "SliceAxis") +} + +func TestAX7_SliceUpdateInplace_Bad(t *core.T) { + symbol := any(SliceUpdateInplace) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SliceUpdateInplace_Bad", "SliceUpdateInplace") +} + +func TestAX7_SliceUpdateInplace_Ugly(t *core.T) { + symbol := any(SliceUpdateInplace) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SliceUpdateInplace_Ugly", "SliceUpdateInplace") +} + +func TestAX7_Softmax_Bad(t *core.T) { + symbol := any(Softmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Softmax_Bad", "Softmax") +} + +func TestAX7_Softmax_Ugly(t *core.T) { + symbol := any(Softmax) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Softmax_Ugly", "Softmax") +} + +func TestAX7_Sort_Bad(t *core.T) { + symbol := any(Sort) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sort_Bad", "Sort") +} + +func TestAX7_Sort_Ugly(t *core.T) { + symbol := any(Sort) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sort_Ugly", "Sort") +} + +func TestAX7_Sqrt_Bad(t *core.T) { + symbol := any(Sqrt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sqrt_Bad", "Sqrt") +} + +func TestAX7_Sqrt_Ugly(t *core.T) { + symbol := any(Sqrt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sqrt_Ugly", "Sqrt") +} + +func TestAX7_Square_Bad(t *core.T) { + symbol := any(Square) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Square_Bad", "Square") +} + +func TestAX7_Square_Ugly(t *core.T) { + symbol := any(Square) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Square_Ugly", "Square") +} + +func TestAX7_Squeeze_Bad(t *core.T) { + symbol := any(Squeeze) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Squeeze_Bad", "Squeeze") +} + +func TestAX7_Squeeze_Ugly(t *core.T) { + symbol := any(Squeeze) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Squeeze_Ugly", "Squeeze") +} + +func TestAX7_Subtract_Bad(t *core.T) { + symbol := any(Subtract) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Subtract_Bad", "Subtract") +} + +func TestAX7_Subtract_Ugly(t *core.T) { + symbol := any(Subtract) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Subtract_Ugly", "Subtract") +} + +func TestAX7_Sum_Bad(t *core.T) { + symbol := any(Sum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sum_Bad", "Sum") +} + +func TestAX7_Sum_Ugly(t *core.T) { + symbol := any(Sum) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Sum_Ugly", "Sum") +} + +func TestAX7_SumAll_Bad(t *core.T) { + symbol := any(SumAll) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SumAll_Bad", "SumAll") +} + +func TestAX7_SumAll_Ugly(t *core.T) { + symbol := any(SumAll) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SumAll_Ugly", "SumAll") +} + +func TestAX7_SwitchLinear_Forward_Good(t *core.T) { + symbol := any((*SwitchLinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SwitchLinear_Forward_Good", "SwitchLinear_Forward") +} + +func TestAX7_SwitchLinear_Forward_Bad(t *core.T) { + symbol := any((*SwitchLinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SwitchLinear_Forward_Bad", "SwitchLinear_Forward") +} + +func TestAX7_SwitchLinear_Forward_Ugly(t *core.T) { + symbol := any((*SwitchLinear).Forward) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "SwitchLinear_Forward_Ugly", "SwitchLinear_Forward") +} + +func TestAX7_Synchronize_Good(t *core.T) { + symbol := any(Synchronize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Synchronize_Good", "Synchronize") +} + +func TestAX7_Synchronize_Bad(t *core.T) { + symbol := any(Synchronize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Synchronize_Bad", "Synchronize") +} + +func TestAX7_Synchronize_Ugly(t *core.T) { + symbol := any(Synchronize) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Synchronize_Ugly", "Synchronize") +} + +func TestAX7_Take_Bad(t *core.T) { + symbol := any(Take) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Take_Bad", "Take") +} + +func TestAX7_Take_Ugly(t *core.T) { + symbol := any(Take) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Take_Ugly", "Take") +} + +func TestAX7_TakeAlongAxis_Bad(t *core.T) { + symbol := any(TakeAlongAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TakeAlongAxis_Bad", "TakeAlongAxis") +} + +func TestAX7_TakeAlongAxis_Ugly(t *core.T) { + symbol := any(TakeAlongAxis) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TakeAlongAxis_Ugly", "TakeAlongAxis") +} + +func TestAX7_Tanh_Bad(t *core.T) { + symbol := any(Tanh) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tanh_Bad", "Tanh") +} + +func TestAX7_Tanh_Ugly(t *core.T) { + symbol := any(Tanh) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tanh_Ugly", "Tanh") +} + +func TestAX7_Temperature_Sample_Good(t *core.T) { + symbol := any(Temperature.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Temperature_Sample_Good", "Temperature_Sample") +} + +func TestAX7_Temperature_Sample_Bad(t *core.T) { + symbol := any(Temperature.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Temperature_Sample_Bad", "Temperature_Sample") +} + +func TestAX7_Temperature_Sample_Ugly(t *core.T) { + symbol := any(Temperature.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Temperature_Sample_Ugly", "Temperature_Sample") +} + +func TestAX7_Tokenizer_BOS_Good(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Good", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Bad(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Bad", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Ugly", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Good", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_BOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Bad", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_BOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Ugly", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_Decode_Good(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Good", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Bad(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Bad", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Ugly", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_DecodeToken_Good(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Good", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_DecodeToken_Bad(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Bad", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_DecodeToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Ugly", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_EOS_Good(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Good", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Bad(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Bad", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Ugly", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Good", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_EOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Bad", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_EOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Ugly", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_Encode_Good(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Good", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Bad(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Bad", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Ugly", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_HasBOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Good", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasBOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Bad", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasBOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Ugly", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Good", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Bad", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Ugly", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_IDToken_Good(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Good", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Bad(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Bad", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Ugly", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_TokenID_Good(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Good", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Bad(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Bad", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Ugly(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Ugly", "Tokenizer_TokenID") +} + +func TestAX7_TopK_Bad(t *core.T) { + symbol := any(TopK) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopK_Bad", "TopK") +} + +func TestAX7_TopK_Ugly(t *core.T) { + symbol := any(TopK) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopK_Ugly", "TopK") +} + +func TestAX7_TopKSampler_Sample_Good(t *core.T) { + symbol := any(TopKSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopKSampler_Sample_Good", "TopKSampler_Sample") +} + +func TestAX7_TopKSampler_Sample_Bad(t *core.T) { + symbol := any(TopKSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopKSampler_Sample_Bad", "TopKSampler_Sample") +} + +func TestAX7_TopKSampler_Sample_Ugly(t *core.T) { + symbol := any(TopKSampler.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopKSampler_Sample_Ugly", "TopKSampler_Sample") +} + +func TestAX7_TopP_Sample_Good(t *core.T) { + symbol := any(TopP.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopP_Sample_Good", "TopP_Sample") +} + +func TestAX7_TopP_Sample_Bad(t *core.T) { + symbol := any(TopP.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopP_Sample_Bad", "TopP_Sample") +} + +func TestAX7_TopP_Sample_Ugly(t *core.T) { + symbol := any(TopP.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "TopP_Sample_Ugly", "TopP_Sample") +} + +func TestAX7_Transpose_Bad(t *core.T) { + symbol := any(Transpose) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Transpose_Bad", "Transpose") +} + +func TestAX7_Transpose_Ugly(t *core.T) { + symbol := any(Transpose) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Transpose_Ugly", "Transpose") +} + +func TestAX7_VJP_Good(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Good", "VJP") +} + +func TestAX7_VJP_Bad(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Bad", "VJP") +} + +func TestAX7_VJP_Ugly(t *core.T) { + symbol := any(VJP) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VJP_Ugly", "VJP") +} + +func TestAX7_ValueAndGrad_Good(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Good", "ValueAndGrad") +} + +func TestAX7_ValueAndGrad_Bad(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Bad", "ValueAndGrad") +} + +func TestAX7_ValueAndGrad_Ugly(t *core.T) { + symbol := any(ValueAndGrad) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "ValueAndGrad_Ugly", "ValueAndGrad") +} + +func TestAX7_VectorArray_Append_Good(t *core.T) { + symbol := any((*VectorArray).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Append_Good", "VectorArray_Append") +} + +func TestAX7_VectorArray_Append_Bad(t *core.T) { + symbol := any((*VectorArray).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Append_Bad", "VectorArray_Append") +} + +func TestAX7_VectorArray_Append_Ugly(t *core.T) { + symbol := any((*VectorArray).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Append_Ugly", "VectorArray_Append") +} + +func TestAX7_VectorArray_Free_Good(t *core.T) { + symbol := any((*VectorArray).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Free_Good", "VectorArray_Free") +} + +func TestAX7_VectorArray_Free_Bad(t *core.T) { + symbol := any((*VectorArray).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Free_Bad", "VectorArray_Free") +} + +func TestAX7_VectorArray_Free_Ugly(t *core.T) { + symbol := any((*VectorArray).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Free_Ugly", "VectorArray_Free") +} + +func TestAX7_VectorArray_Get_Good(t *core.T) { + symbol := any((*VectorArray).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Get_Good", "VectorArray_Get") +} + +func TestAX7_VectorArray_Get_Bad(t *core.T) { + symbol := any((*VectorArray).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Get_Bad", "VectorArray_Get") +} + +func TestAX7_VectorArray_Get_Ugly(t *core.T) { + symbol := any((*VectorArray).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Get_Ugly", "VectorArray_Get") +} + +func TestAX7_VectorArray_SetValue_Good(t *core.T) { + symbol := any((*VectorArray).SetValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_SetValue_Good", "VectorArray_SetValue") +} + +func TestAX7_VectorArray_SetValue_Bad(t *core.T) { + symbol := any((*VectorArray).SetValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_SetValue_Bad", "VectorArray_SetValue") +} + +func TestAX7_VectorArray_SetValue_Ugly(t *core.T) { + symbol := any((*VectorArray).SetValue) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_SetValue_Ugly", "VectorArray_SetValue") +} + +func TestAX7_VectorArray_Size_Good(t *core.T) { + symbol := any((*VectorArray).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Size_Good", "VectorArray_Size") +} + +func TestAX7_VectorArray_Size_Bad(t *core.T) { + symbol := any((*VectorArray).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Size_Bad", "VectorArray_Size") +} + +func TestAX7_VectorArray_Size_Ugly(t *core.T) { + symbol := any((*VectorArray).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorArray_Size_Ugly", "VectorArray_Size") +} + +func TestAX7_VectorString_Append_Good(t *core.T) { + symbol := any((*VectorString).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Append_Good", "VectorString_Append") +} + +func TestAX7_VectorString_Append_Bad(t *core.T) { + symbol := any((*VectorString).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Append_Bad", "VectorString_Append") +} + +func TestAX7_VectorString_Append_Ugly(t *core.T) { + symbol := any((*VectorString).Append) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Append_Ugly", "VectorString_Append") +} + +func TestAX7_VectorString_Free_Good(t *core.T) { + symbol := any((*VectorString).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Free_Good", "VectorString_Free") +} + +func TestAX7_VectorString_Free_Bad(t *core.T) { + symbol := any((*VectorString).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Free_Bad", "VectorString_Free") +} + +func TestAX7_VectorString_Free_Ugly(t *core.T) { + symbol := any((*VectorString).Free) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Free_Ugly", "VectorString_Free") +} + +func TestAX7_VectorString_Get_Good(t *core.T) { + symbol := any((*VectorString).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Get_Good", "VectorString_Get") +} + +func TestAX7_VectorString_Get_Bad(t *core.T) { + symbol := any((*VectorString).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Get_Bad", "VectorString_Get") +} + +func TestAX7_VectorString_Get_Ugly(t *core.T) { + symbol := any((*VectorString).Get) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Get_Ugly", "VectorString_Get") +} + +func TestAX7_VectorString_Size_Good(t *core.T) { + symbol := any((*VectorString).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Size_Good", "VectorString_Size") +} + +func TestAX7_VectorString_Size_Bad(t *core.T) { + symbol := any((*VectorString).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Size_Bad", "VectorString_Size") +} + +func TestAX7_VectorString_Size_Ugly(t *core.T) { + symbol := any((*VectorString).Size) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "VectorString_Size_Ugly", "VectorString_Size") +} + +func TestAX7_Version_Good(t *core.T) { + symbol := any(Version) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Version_Good", "Version") +} + +func TestAX7_Version_Bad(t *core.T) { + symbol := any(Version) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Version_Bad", "Version") +} + +func TestAX7_Version_Ugly(t *core.T) { + symbol := any(Version) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Version_Ugly", "Version") +} + +func TestAX7_Where_Bad(t *core.T) { + symbol := any(Where) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Where_Bad", "Where") +} + +func TestAX7_Where_Ugly(t *core.T) { + symbol := any(Where) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Where_Ugly", "Where") +} + +func TestAX7_Zeros_Bad(t *core.T) { + symbol := any(Zeros) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Zeros_Bad", "Zeros") +} + +func TestAX7_Zeros_Ugly(t *core.T) { + symbol := any(Zeros) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Zeros_Ugly", "Zeros") +} + +func TestAX7_chain_Sample_Good(t *core.T) { + symbol := any(chain.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "chain_Sample_Good", "chain_Sample") +} + +func TestAX7_chain_Sample_Bad(t *core.T) { + symbol := any(chain.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "chain_Sample_Bad", "chain_Sample") +} + +func TestAX7_chain_Sample_Ugly(t *core.T) { + symbol := any(chain.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "chain_Sample_Ugly", "chain_Sample") +} + +func TestAX7_greedy_Sample_Good(t *core.T) { + symbol := any(greedy.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "greedy_Sample_Good", "greedy_Sample") +} + +func TestAX7_greedy_Sample_Bad(t *core.T) { + symbol := any(greedy.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "greedy_Sample_Bad", "greedy_Sample") +} + +func TestAX7_greedy_Sample_Ugly(t *core.T) { + symbol := any(greedy.Sample) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "greedy_Sample_Ugly", "greedy_Sample") +} diff --git a/internal/metal/backend.go b/internal/metal/backend.go index d18a7b9..d7d4026 100644 --- a/internal/metal/backend.go +++ b/internal/metal/backend.go @@ -4,7 +4,7 @@ package metal -import "dappco.re/go/core" +import "dappco.re/go" var runtimeMetalAvailable = MetalAvailable diff --git a/internal/metal/batch.go b/internal/metal/batch.go index a204859..a6c0617 100644 --- a/internal/metal/batch.go +++ b/internal/metal/batch.go @@ -11,7 +11,7 @@ import ( "slices" "time" - "dappco.re/go/core" + "dappco.re/go" ) // ClassifyResult holds the output for a single prompt in batch classification. diff --git a/internal/metal/close_test.go b/internal/metal/close_test.go index 4b399e3..4b84be3 100644 --- a/internal/metal/close_test.go +++ b/internal/metal/close_test.go @@ -25,7 +25,13 @@ func TestClose_FreeLinear_Good(t *testing.T) { } func TestClose_FreeLinear_Nil_Good(t *testing.T) { - freeLinear(nil) // should not panic + defer func() { + if recovered := recover(); recovered != nil { + t.Fatalf("freeLinear(nil) panicked: %v", recovered) + } + }() + + freeLinear(nil) } func TestClose_FreeEmbedding_Good(t *testing.T) { diff --git a/internal/metal/device.go b/internal/metal/device.go index aa02149..410cebb 100644 --- a/internal/metal/device.go +++ b/internal/metal/device.go @@ -12,7 +12,7 @@ import "C" import ( "sync" - "dappco.re/go/core" + "dappco.re/go" ) // DeviceType is the MLX execution device used by the root-package API. diff --git a/internal/metal/dtype.go b/internal/metal/dtype.go index 3348219..220dcc3 100644 --- a/internal/metal/dtype.go +++ b/internal/metal/dtype.go @@ -7,7 +7,7 @@ package metal // #include "mlx/c/mlx.h" import "C" -import "dappco.re/go/core" +import "dappco.re/go" // DType represents an MLX array data type. type DType C.mlx_dtype diff --git a/internal/metal/export.go b/internal/metal/export.go index 2f24095..7203410 100644 --- a/internal/metal/export.go +++ b/internal/metal/export.go @@ -56,7 +56,7 @@ import ( "sync/atomic" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // --------------------------------------------------------------------------- diff --git a/internal/metal/gemma3.go b/internal/metal/gemma3.go index d378d0c..d08ade4 100644 --- a/internal/metal/gemma3.go +++ b/internal/metal/gemma3.go @@ -7,7 +7,7 @@ package metal import ( "math" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/gemma4.go b/internal/metal/gemma4.go index a5fd67d..3f76471 100644 --- a/internal/metal/gemma4.go +++ b/internal/metal/gemma4.go @@ -7,7 +7,7 @@ package metal import ( "math" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/gemma4_test.go b/internal/metal/gemma4_test.go index aa5d028..60ea22b 100644 --- a/internal/metal/gemma4_test.go +++ b/internal/metal/gemma4_test.go @@ -9,7 +9,7 @@ import ( "strings" "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/gemma4_vision.go b/internal/metal/gemma4_vision.go index e049594..baffb51 100644 --- a/internal/metal/gemma4_vision.go +++ b/internal/metal/gemma4_vision.go @@ -8,7 +8,7 @@ import ( "math" "strings" - "dappco.re/go/core" + "dappco.re/go" ) // Gemma4VisionRopeParameters holds the 2-D RoPE settings for the vision tower. diff --git a/internal/metal/generate.go b/internal/metal/generate.go index 8275bba..6da8611 100644 --- a/internal/metal/generate.go +++ b/internal/metal/generate.go @@ -10,7 +10,7 @@ import ( "slices" "time" - "dappco.re/go/core" + "dappco.re/go" ) // Token represents a single generated token. diff --git a/internal/metal/gguf.go b/internal/metal/gguf.go index 9058758..61e7fe3 100644 --- a/internal/metal/gguf.go +++ b/internal/metal/gguf.go @@ -18,7 +18,7 @@ import ( "runtime" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // LoadGGUF loads tensors from a .gguf file, returning an iterator over diff --git a/internal/metal/grad.go b/internal/metal/grad.go index e8e3fbc..2cdad4a 100644 --- a/internal/metal/grad.go +++ b/internal/metal/grad.go @@ -27,7 +27,7 @@ import ( "sync/atomic" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) var ( diff --git a/internal/metal/io.go b/internal/metal/io.go index 9319231..e228d64 100644 --- a/internal/metal/io.go +++ b/internal/metal/io.go @@ -15,7 +15,7 @@ import ( "runtime" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // LoadSafetensors loads tensors from a .safetensors file, returning an iterator diff --git a/internal/metal/io_custom.go b/internal/metal/io_custom.go index 191bbcf..9b8b1e7 100644 --- a/internal/metal/io_custom.go +++ b/internal/metal/io_custom.go @@ -67,7 +67,7 @@ import ( "sync" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // ioStream is the Go-side descriptor passed through C void* callbacks. diff --git a/internal/metal/io_custom_test.go b/internal/metal/io_custom_test.go index 16865b4..27c9c3f 100644 --- a/internal/metal/io_custom_test.go +++ b/internal/metal/io_custom_test.go @@ -11,8 +11,8 @@ import ( "testing" ) -// bytesRWS wraps a bytes.Buffer to satisfy io.ReadWriteSeeker. -// bytes.Buffer only provides Read and Write; this adds Seek support. +// bytesRWS implements io.ReadWriteSeeker over an internal byte slice. +// It tracks the current position and high-water length for Read, Write, and Seek. type bytesRWS struct { data []byte pos int @@ -144,6 +144,9 @@ func TestIOCustom_RoundTrip_Good(t *testing.T) { t.Errorf("weight size = %d, want 4", w.Size()) } wShape := w.Shape() + if len(wShape) < 2 { + t.Fatalf("weight shape = %v, want at least rank 2", wShape) + } if wShape[0] != 2 || wShape[1] != 2 { t.Errorf("weight shape = %v, want [2 2]", wShape) } diff --git a/internal/metal/lora.go b/internal/metal/lora.go index 58e08a4..57f22b5 100644 --- a/internal/metal/lora.go +++ b/internal/metal/lora.go @@ -18,7 +18,7 @@ import ( "strconv" "unsafe" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/lora_test.go b/internal/metal/lora_test.go index 6af63bd..07c085a 100644 --- a/internal/metal/lora_test.go +++ b/internal/metal/lora_test.go @@ -8,7 +8,7 @@ import ( "math" "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/metal.go b/internal/metal/metal.go index 5d8a651..cd32f2f 100644 --- a/internal/metal/metal.go +++ b/internal/metal/metal.go @@ -15,6 +15,7 @@ package metal #cgo CPPFLAGS: -I${SRCDIR}/../../lib/fmt/include #cgo CPPFLAGS: -I${SRCDIR}/../../lib/gguflib #cgo CPPFLAGS: -I${SRCDIR}/../../lib/json/single_include/nlohmann +#cgo CPPFLAGS: -I${SRCDIR}/../../dist/include #cgo CPPFLAGS: -I${SRCDIR}/../../dist/include/metal_cpp #cgo darwin LDFLAGS: -framework Foundation -framework Metal -framework Accelerate -framework QuartzCore @@ -65,7 +66,7 @@ import ( "sync" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) var initOnce sync.Once diff --git a/internal/metal/metal_kernel.go b/internal/metal/metal_kernel.go index 4c1fd95..8ad56df 100644 --- a/internal/metal/metal_kernel.go +++ b/internal/metal/metal_kernel.go @@ -14,7 +14,7 @@ import ( "runtime" "unsafe" - "dappco.re/go/core" + "dappco.re/go" ) // MetalKernel wraps a custom Metal shader kernel for GPU execution. diff --git a/internal/metal/mlx_build_config.h b/internal/metal/mlx_build_config.h index adeda36..bf3196f 100644 --- a/internal/metal/mlx_build_config.h +++ b/internal/metal/mlx_build_config.h @@ -3,6 +3,9 @@ #define ACCELERATE_NEW_LAPACK 1 #define FMT_HEADER_ONLY 1 #define MLX_BUILD_GGUF 1 +#ifndef MLX_ENABLE_DISTRIBUTED +#define MLX_ENABLE_DISTRIBUTED 1 +#endif #define MLX_USE_ACCELERATE 1 #define MLX_VERSION "0.30.1" diff --git a/internal/metal/mlx_mlx_backend_cpu_distributed.cpp b/internal/metal/mlx_mlx_backend_cpu_distributed.cpp index 2364fed..77e8ed8 100644 --- a/internal/metal/mlx_mlx_backend_cpu_distributed.cpp +++ b/internal/metal/mlx_mlx_backend_cpu_distributed.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/backend/cpu/distributed.cpp") #include "../../lib/mlx/mlx/backend/cpu/distributed.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/backend/cpu/distributed.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_backend_cpu_scan.cpp b/internal/metal/mlx_mlx_backend_cpu_scan.cpp index c5b2a43..eb6b3d7 100644 --- a/internal/metal/mlx_mlx_backend_cpu_scan.cpp +++ b/internal/metal/mlx_mlx_backend_cpu_scan.cpp @@ -1,5 +1,9 @@ -#if defined(__has_include) && __has_include("../../lib/mlx/mlx/backend/cpu/scan.cpp") -#include "../../lib/mlx/mlx/backend/cpu/scan.cpp" +#if defined(__has_include) +# if __has_include("../../lib/mlx/mlx/backend/cpu/scan.cpp") +# include "../../lib/mlx/mlx/backend/cpu/scan.cpp" +# else +# error "Missing forwarded source: ../../lib/mlx/mlx/backend/cpu/scan.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# endif #else -#error "Missing forwarded source: ../../lib/mlx/mlx/backend/cpu/scan.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# include "../../lib/mlx/mlx/backend/cpu/scan.cpp" #endif diff --git a/internal/metal/mlx_mlx_backend_metal_distributed.cpp b/internal/metal/mlx_mlx_backend_metal_distributed.cpp index 23894a9..60e7df3 100644 --- a/internal/metal/mlx_mlx_backend_metal_distributed.cpp +++ b/internal/metal/mlx_mlx_backend_metal_distributed.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/backend/metal/distributed.cpp") #include "../../lib/mlx/mlx/backend/metal/distributed.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/backend/metal/distributed.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_backend_metal_indexing.cpp b/internal/metal/mlx_mlx_backend_metal_indexing.cpp index 2494b73..5a6ebe9 100644 --- a/internal/metal/mlx_mlx_backend_metal_indexing.cpp +++ b/internal/metal/mlx_mlx_backend_metal_indexing.cpp @@ -1,5 +1,9 @@ -#if defined(__has_include) && __has_include("../../lib/mlx/mlx/backend/metal/indexing.cpp") -#include "../../lib/mlx/mlx/backend/metal/indexing.cpp" +#if defined(__has_include) +# if __has_include("../../lib/mlx/mlx/backend/metal/indexing.cpp") +# include "../../lib/mlx/mlx/backend/metal/indexing.cpp" +# else +# error "Missing forwarded source: ../../lib/mlx/mlx/backend/metal/indexing.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# endif #else -#error "Missing forwarded source: ../../lib/mlx/mlx/backend/metal/indexing.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# error "Compiler does not support __has_include; cannot verify forwarded source: ../../lib/mlx/mlx/backend/metal/indexing.cpp." #endif diff --git a/internal/metal/mlx_mlx_distributed_distributed.cpp b/internal/metal/mlx_mlx_distributed_distributed.cpp index 7042a97..76c8635 100644 --- a/internal/metal/mlx_mlx_distributed_distributed.cpp +++ b/internal/metal/mlx_mlx_distributed_distributed.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/distributed.cpp") #include "../../lib/mlx/mlx/distributed/distributed.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/distributed.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_jaccl_no_jaccl.cpp b/internal/metal/mlx_mlx_distributed_jaccl_no_jaccl.cpp index 54821b8..44b8aa7 100644 --- a/internal/metal/mlx_mlx_distributed_jaccl_no_jaccl.cpp +++ b/internal/metal/mlx_mlx_distributed_jaccl_no_jaccl.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/jaccl/no_jaccl.cpp") #include "../../lib/mlx/mlx/distributed/jaccl/no_jaccl.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/jaccl/no_jaccl.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_mpi_no_mpi.cpp b/internal/metal/mlx_mlx_distributed_mpi_no_mpi.cpp index 1659818..f55a19e 100644 --- a/internal/metal/mlx_mlx_distributed_mpi_no_mpi.cpp +++ b/internal/metal/mlx_mlx_distributed_mpi_no_mpi.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/mpi/no_mpi.cpp") #include "../../lib/mlx/mlx/distributed/mpi/no_mpi.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/mpi/no_mpi.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_nccl_no_nccl.cpp b/internal/metal/mlx_mlx_distributed_nccl_no_nccl.cpp index 42ef068..d26ad99 100644 --- a/internal/metal/mlx_mlx_distributed_nccl_no_nccl.cpp +++ b/internal/metal/mlx_mlx_distributed_nccl_no_nccl.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/nccl/no_nccl.cpp") #include "../../lib/mlx/mlx/distributed/nccl/no_nccl.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/nccl/no_nccl.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_ops.cpp b/internal/metal/mlx_mlx_distributed_ops.cpp index 56b4184..eb0c0e4 100644 --- a/internal/metal/mlx_mlx_distributed_ops.cpp +++ b/internal/metal/mlx_mlx_distributed_ops.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/ops.cpp") #include "../../lib/mlx/mlx/distributed/ops.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/ops.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_primitives.cpp b/internal/metal/mlx_mlx_distributed_primitives.cpp index 021249c..13a9409 100644 --- a/internal/metal/mlx_mlx_distributed_primitives.cpp +++ b/internal/metal/mlx_mlx_distributed_primitives.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/primitives.cpp") #include "../../lib/mlx/mlx/distributed/primitives.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/primitives.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_ring_no_ring.cpp b/internal/metal/mlx_mlx_distributed_ring_no_ring.cpp index 9f89a96..71a54ee 100644 --- a/internal/metal/mlx_mlx_distributed_ring_no_ring.cpp +++ b/internal/metal/mlx_mlx_distributed_ring_no_ring.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/ring/no_ring.cpp") #include "../../lib/mlx/mlx/distributed/ring/no_ring.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/ring/no_ring.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_distributed_utils.cpp b/internal/metal/mlx_mlx_distributed_utils.cpp index 4f86d84..a27eab4 100644 --- a/internal/metal/mlx_mlx_distributed_utils.cpp +++ b/internal/metal/mlx_mlx_distributed_utils.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx/mlx/distributed/utils.cpp") #include "../../lib/mlx/mlx/distributed/utils.cpp" #else #error "Missing forwarded source: ../../lib/mlx/mlx/distributed/utils.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlx_mlx_graph_utils.cpp b/internal/metal/mlx_mlx_graph_utils.cpp index 6a530e9..2680599 100644 --- a/internal/metal/mlx_mlx_graph_utils.cpp +++ b/internal/metal/mlx_mlx_graph_utils.cpp @@ -1,5 +1,9 @@ -#if defined(__has_include) && __has_include("../../lib/mlx/mlx/graph_utils.cpp") -#include "../../lib/mlx/mlx/graph_utils.cpp" +#if defined(__has_include) +# if __has_include("../../lib/mlx/mlx/graph_utils.cpp") +# include "../../lib/mlx/mlx/graph_utils.cpp" +# else +# error "Missing forwarded source: ../../lib/mlx/mlx/graph_utils.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# endif #else -#error "Missing forwarded source: ../../lib/mlx/mlx/graph_utils.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." +# error "Compiler does not support __has_include; cannot verify forwarded source: ../../lib/mlx/mlx/graph_utils.cpp." #endif diff --git a/internal/metal/mlx_mlx_io_no_gguf.cpp b/internal/metal/mlx_mlx_io_no_gguf.cpp index 2712e34..da08f0c 100644 --- a/internal/metal/mlx_mlx_io_no_gguf.cpp +++ b/internal/metal/mlx_mlx_io_no_gguf.cpp @@ -1,5 +1,3 @@ -#if defined(__has_include) && __has_include("../../lib/mlx/mlx/io/no_gguf.cpp") -#include "../../lib/mlx/mlx/io/no_gguf.cpp" -#else -#error "Missing forwarded source: ../../lib/mlx/mlx/io/no_gguf.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." -#endif +// GGUF support is enabled for go-mlx, so the real gguf.cpp translation unit is +// compiled. Do not also compile MLX's no_gguf.cpp fallback, which defines the +// same load_gguf/save_gguf symbols. diff --git a/internal/metal/mlxc_distributed.cpp b/internal/metal/mlxc_distributed.cpp index 2539f57..e0c0acb 100644 --- a/internal/metal/mlxc_distributed.cpp +++ b/internal/metal/mlxc_distributed.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx-c/mlx/c/distributed.cpp") #include "../../lib/mlx-c/mlx/c/distributed.cpp" #else #error "Missing forwarded source: ../../lib/mlx-c/mlx/c/distributed.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/mlxc_distributed_group.cpp b/internal/metal/mlxc_distributed_group.cpp index c54156f..f6996f3 100644 --- a/internal/metal/mlxc_distributed_group.cpp +++ b/internal/metal/mlxc_distributed_group.cpp @@ -1,5 +1,9 @@ +#if defined(MLX_ENABLE_DISTRIBUTED) && !MLX_ENABLE_DISTRIBUTED +// MLX distributed support is disabled for this build. +#else #if defined(__has_include) && __has_include("../../lib/mlx-c/mlx/c/distributed_group.cpp") #include "../../lib/mlx-c/mlx/c/distributed_group.cpp" #else #error "Missing forwarded source: ../../lib/mlx-c/mlx/c/distributed_group.cpp. Initialise submodules with git submodule update --init --recursive or fix the forwarding include path." #endif +#endif diff --git a/internal/metal/model.go b/internal/metal/model.go index 0452e7e..7398108 100644 --- a/internal/metal/model.go +++ b/internal/metal/model.go @@ -5,7 +5,7 @@ package metal import ( - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/model_files.go b/internal/metal/model_files.go index ba42790..e909c57 100644 --- a/internal/metal/model_files.go +++ b/internal/metal/model_files.go @@ -8,7 +8,7 @@ import ( "maps" "os" - "dappco.re/go/core" + "dappco.re/go" ) func resolveModelRoot(modelPath string) string { diff --git a/internal/metal/model_test.go b/internal/metal/model_test.go index 771f4ee..0f25dd0 100644 --- a/internal/metal/model_test.go +++ b/internal/metal/model_test.go @@ -7,7 +7,7 @@ package metal import ( "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/qwen3.go b/internal/metal/qwen3.go index d479486..c1e8694 100644 --- a/internal/metal/qwen3.go +++ b/internal/metal/qwen3.go @@ -7,7 +7,7 @@ package metal import ( "math" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/stream.go b/internal/metal/stream.go index 3494534..285463b 100644 --- a/internal/metal/stream.go +++ b/internal/metal/stream.go @@ -73,6 +73,9 @@ func Synchronize(s *Stream) { // // prev := metal.SetMemoryLimit(32 << 30) // 32 GB hard limit func SetMemoryLimit(limit uint64) uint64 { + if !MetalAvailable() { + return 0 + } var prev C.size_t C.mlx_set_memory_limit(&prev, C.size_t(limit)) return uint64(prev) @@ -82,6 +85,9 @@ func SetMemoryLimit(limit uint64) uint64 { // // prev := metal.SetCacheLimit(4 << 30) // 4 GB cache limit func SetCacheLimit(limit uint64) uint64 { + if !MetalAvailable() { + return 0 + } var prev C.size_t C.mlx_set_cache_limit(&prev, C.size_t(limit)) return uint64(prev) @@ -91,6 +97,9 @@ func SetCacheLimit(limit uint64) uint64 { // // fmt.Printf("active: %d MB\n", metal.GetActiveMemory()/1024/1024) func GetActiveMemory() uint64 { + if !MetalAvailable() { + return 0 + } var mem C.size_t C.mlx_get_active_memory(&mem) return uint64(mem) @@ -100,6 +109,9 @@ func GetActiveMemory() uint64 { // // fmt.Printf("peak: %d MB\n", metal.GetPeakMemory()/1024/1024) func GetPeakMemory() uint64 { + if !MetalAvailable() { + return 0 + } var mem C.size_t C.mlx_get_peak_memory(&mem) return uint64(mem) @@ -109,6 +121,9 @@ func GetPeakMemory() uint64 { // // metal.ClearCache() // between chat turns to reclaim prompt cache memory func ClearCache() { + if !MetalAvailable() { + return + } C.mlx_clear_cache() } @@ -116,6 +131,9 @@ func ClearCache() { // // fmt.Printf("cache: %d MB\n", metal.GetCacheMemory()/1024/1024) func GetCacheMemory() uint64 { + if !MetalAvailable() { + return 0 + } var mem C.size_t C.mlx_get_cache_memory(&mem) return uint64(mem) @@ -125,6 +143,9 @@ func GetCacheMemory() uint64 { // // metal.ResetPeakMemory() // before each generate call to measure per-call peak func ResetPeakMemory() { + if !MetalAvailable() { + return + } C.mlx_reset_peak_memory() } @@ -132,6 +153,9 @@ func ResetPeakMemory() { // // prev := metal.SetWiredLimit(8 << 30) // 8 GB wired memory limit func SetWiredLimit(limit uint64) uint64 { + if !MetalAvailable() { + return 0 + } var prev C.size_t C.mlx_set_wired_limit(&prev, C.size_t(limit)) return uint64(prev) diff --git a/internal/metal/tokenizer.go b/internal/metal/tokenizer.go index 56195ae..961fd4e 100644 --- a/internal/metal/tokenizer.go +++ b/internal/metal/tokenizer.go @@ -7,7 +7,7 @@ package metal import ( "slices" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/tokenizer_test.go b/internal/metal/tokenizer_test.go index fc69a80..626f952 100644 --- a/internal/metal/tokenizer_test.go +++ b/internal/metal/tokenizer_test.go @@ -7,7 +7,7 @@ package metal import ( "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/train_test.go b/internal/metal/train_test.go index 2a78885..35663f2 100644 --- a/internal/metal/train_test.go +++ b/internal/metal/train_test.go @@ -8,7 +8,7 @@ import ( "math" "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/metal/training.go b/internal/metal/training.go index e935465..1019a70 100644 --- a/internal/metal/training.go +++ b/internal/metal/training.go @@ -4,7 +4,7 @@ package metal -import "dappco.re/go/core" +import "dappco.re/go" // ApplyLoRA injects LoRA adapters into the model's projection layers. // diff --git a/internal/tokenizer/ax7_generated_test.go b/internal/tokenizer/ax7_generated_test.go new file mode 100644 index 0000000..0d65f34 --- /dev/null +++ b/internal/tokenizer/ax7_generated_test.go @@ -0,0 +1,227 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +package tokenizer + +import core "dappco.re/go" + +func TestAX7_FormatGemmaPrompt_Bad(t *core.T) { + symbol := any(FormatGemmaPrompt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FormatGemmaPrompt_Bad", "FormatGemmaPrompt") +} + +func TestAX7_FormatGemmaPrompt_Ugly(t *core.T) { + symbol := any(FormatGemmaPrompt) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "FormatGemmaPrompt_Ugly", "FormatGemmaPrompt") +} + +func TestAX7_LoadTokenizer_Bad(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Bad", "LoadTokenizer") +} + +func TestAX7_LoadTokenizer_Ugly(t *core.T) { + symbol := any(LoadTokenizer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LoadTokenizer_Ugly", "LoadTokenizer") +} + +func TestAX7_Tokenizer_BOS_Good(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Good", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Bad(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Bad", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).BOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOS_Ugly", "Tokenizer_BOS") +} + +func TestAX7_Tokenizer_BOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Good", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_BOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Bad", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_BOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).BOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_BOSToken_Ugly", "Tokenizer_BOSToken") +} + +func TestAX7_Tokenizer_Decode_Good(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Good", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Bad(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Bad", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_Decode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Decode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Decode_Ugly", "Tokenizer_Decode") +} + +func TestAX7_Tokenizer_DecodeToken_Good(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Good", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_DecodeToken_Bad(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Bad", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_DecodeToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).DecodeToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_DecodeToken_Ugly", "Tokenizer_DecodeToken") +} + +func TestAX7_Tokenizer_EOS_Good(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Good", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Bad(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Bad", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOS_Ugly(t *core.T) { + symbol := any((*Tokenizer).EOS) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOS_Ugly", "Tokenizer_EOS") +} + +func TestAX7_Tokenizer_EOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Good", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_EOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Bad", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_EOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).EOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_EOSToken_Ugly", "Tokenizer_EOSToken") +} + +func TestAX7_Tokenizer_Encode_Good(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Good", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Bad(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Bad", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_Encode_Ugly(t *core.T) { + symbol := any((*Tokenizer).Encode) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_Encode_Ugly", "Tokenizer_Encode") +} + +func TestAX7_Tokenizer_HasBOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Good", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasBOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Bad", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasBOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).HasBOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasBOSToken_Ugly", "Tokenizer_HasBOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Good(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Good", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Bad(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Bad", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_HasEOSToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).HasEOSToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_HasEOSToken_Ugly", "Tokenizer_HasEOSToken") +} + +func TestAX7_Tokenizer_IDToken_Good(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Good", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Bad(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Bad", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_IDToken_Ugly(t *core.T) { + symbol := any((*Tokenizer).IDToken) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_IDToken_Ugly", "Tokenizer_IDToken") +} + +func TestAX7_Tokenizer_TokenID_Good(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Good", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Bad(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Bad", "Tokenizer_TokenID") +} + +func TestAX7_Tokenizer_TokenID_Ugly(t *core.T) { + symbol := any((*Tokenizer).TokenID) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Tokenizer_TokenID_Ugly", "Tokenizer_TokenID") +} diff --git a/internal/tokenizer/tokenizer.go b/internal/tokenizer/tokenizer.go index 1a99c0b..99d79ed 100644 --- a/internal/tokenizer/tokenizer.go +++ b/internal/tokenizer/tokenizer.go @@ -5,7 +5,7 @@ package tokenizer import ( "slices" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/internal/tokenizer/tokenizer_test.go b/internal/tokenizer/tokenizer_test.go index 6526797..75af688 100644 --- a/internal/tokenizer/tokenizer_test.go +++ b/internal/tokenizer/tokenizer_test.go @@ -5,7 +5,7 @@ package tokenizer import ( "testing" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) diff --git a/medium.go b/medium.go index 61014d7..583ee80 100644 --- a/medium.go +++ b/medium.go @@ -10,7 +10,7 @@ import ( "path/filepath" "strings" - "dappco.re/go/core" + "dappco.re/go" coreio "dappco.re/go/io" ) @@ -46,7 +46,9 @@ func stagePathFromMedium(medium coreio.Medium, path string) (string, func() erro } if err := copyMediumTree(medium, root, stageDir); err != nil { - _ = cleanup() + if cleanupErr := cleanup(); cleanupErr != nil { + core.Warn("mlx: cleanup staging dir after copy failure", "error", cleanupErr) + } return "", nil, core.E("mlx.stagePathFromMedium", "stage path tree", err) } diff --git a/mlx_test.go b/mlx_test.go index 207f58d..74e9dc8 100644 --- a/mlx_test.go +++ b/mlx_test.go @@ -9,7 +9,7 @@ import ( "testing" "time" - "dappco.re/go/core" + "dappco.re/go" "dappco.re/go/inference" coreio "dappco.re/go/io" diff --git a/mlxlm/ax7_generated_test.go b/mlxlm/ax7_generated_test.go new file mode 100644 index 0000000..cac5505 --- /dev/null +++ b/mlxlm/ax7_generated_test.go @@ -0,0 +1,295 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +//go:build !nomlxlm + +package mlxlm + +import core "dappco.re/go" + +func TestAX7_Backend_Available_Good(t *core.T) { + symbol := any((*mlxlmBackend).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Good", "Backend_Available") +} + +func TestAX7_Backend_Available_Bad(t *core.T) { + symbol := any((*mlxlmBackend).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Bad", "Backend_Available") +} + +func TestAX7_Backend_Available_Ugly(t *core.T) { + symbol := any((*mlxlmBackend).Available) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Available_Ugly", "Backend_Available") +} + +func TestAX7_Backend_LoadModel_Good(t *core.T) { + symbol := any((*mlxlmBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Good", "Backend_LoadModel") +} + +func TestAX7_Backend_LoadModel_Bad(t *core.T) { + symbol := any((*mlxlmBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Bad", "Backend_LoadModel") +} + +func TestAX7_Backend_LoadModel_Ugly(t *core.T) { + symbol := any((*mlxlmBackend).LoadModel) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_LoadModel_Ugly", "Backend_LoadModel") +} + +func TestAX7_Backend_Name_Good(t *core.T) { + symbol := any((*mlxlmBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Good", "Backend_Name") +} + +func TestAX7_Backend_Name_Bad(t *core.T) { + symbol := any((*mlxlmBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Bad", "Backend_Name") +} + +func TestAX7_Backend_Name_Ugly(t *core.T) { + symbol := any((*mlxlmBackend).Name) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Backend_Name_Ugly", "Backend_Name") +} + +func TestAX7_LineReader_ReadLine_Good(t *core.T) { + symbol := any((*jsonLineReader).ReadLine) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LineReader_ReadLine_Good", "LineReader_ReadLine") +} + +func TestAX7_LineReader_ReadLine_Bad(t *core.T) { + symbol := any((*jsonLineReader).ReadLine) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LineReader_ReadLine_Bad", "LineReader_ReadLine") +} + +func TestAX7_LineReader_ReadLine_Ugly(t *core.T) { + symbol := any((*jsonLineReader).ReadLine) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "LineReader_ReadLine_Ugly", "LineReader_ReadLine") +} + +func TestAX7_Model_BatchGenerate_Good(t *core.T) { + symbol := any((*mlxlmModel).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Good", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Bad(t *core.T) { + symbol := any((*mlxlmModel).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Bad", "Model_BatchGenerate") +} + +func TestAX7_Model_BatchGenerate_Ugly(t *core.T) { + symbol := any((*mlxlmModel).BatchGenerate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_BatchGenerate_Ugly", "Model_BatchGenerate") +} + +func TestAX7_Model_Chat_Good(t *core.T) { + symbol := any((*mlxlmModel).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Good", "Model_Chat") +} + +func TestAX7_Model_Chat_Bad(t *core.T) { + symbol := any((*mlxlmModel).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Bad", "Model_Chat") +} + +func TestAX7_Model_Chat_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Chat) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Chat_Ugly", "Model_Chat") +} + +func TestAX7_Model_Classify_Good(t *core.T) { + symbol := any((*mlxlmModel).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Good", "Model_Classify") +} + +func TestAX7_Model_Classify_Bad(t *core.T) { + symbol := any((*mlxlmModel).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Bad", "Model_Classify") +} + +func TestAX7_Model_Classify_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Classify) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Classify_Ugly", "Model_Classify") +} + +func TestAX7_Model_Close_Good(t *core.T) { + symbol := any((*mlxlmModel).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Good", "Model_Close") +} + +func TestAX7_Model_Close_Bad(t *core.T) { + symbol := any((*mlxlmModel).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Bad", "Model_Close") +} + +func TestAX7_Model_Close_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Close) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Close_Ugly", "Model_Close") +} + +func TestAX7_Model_Err_Good(t *core.T) { + symbol := any((*mlxlmModel).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Good", "Model_Err") +} + +func TestAX7_Model_Err_Bad(t *core.T) { + symbol := any((*mlxlmModel).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Bad", "Model_Err") +} + +func TestAX7_Model_Err_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Err) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Err_Ugly", "Model_Err") +} + +func TestAX7_Model_Generate_Good(t *core.T) { + symbol := any((*mlxlmModel).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Good", "Model_Generate") +} + +func TestAX7_Model_Generate_Bad(t *core.T) { + symbol := any((*mlxlmModel).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Bad", "Model_Generate") +} + +func TestAX7_Model_Generate_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Generate) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Generate_Ugly", "Model_Generate") +} + +func TestAX7_Model_Info_Good(t *core.T) { + symbol := any((*mlxlmModel).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Good", "Model_Info") +} + +func TestAX7_Model_Info_Bad(t *core.T) { + symbol := any((*mlxlmModel).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Bad", "Model_Info") +} + +func TestAX7_Model_Info_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Info) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Info_Ugly", "Model_Info") +} + +func TestAX7_Model_InspectAttention_Good(t *core.T) { + symbol := any((*mlxlmModel).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Good", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Bad(t *core.T) { + symbol := any((*mlxlmModel).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Bad", "Model_InspectAttention") +} + +func TestAX7_Model_InspectAttention_Ugly(t *core.T) { + symbol := any((*mlxlmModel).InspectAttention) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_InspectAttention_Ugly", "Model_InspectAttention") +} + +func TestAX7_Model_Metrics_Good(t *core.T) { + symbol := any((*mlxlmModel).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Good", "Model_Metrics") +} + +func TestAX7_Model_Metrics_Bad(t *core.T) { + symbol := any((*mlxlmModel).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Bad", "Model_Metrics") +} + +func TestAX7_Model_Metrics_Ugly(t *core.T) { + symbol := any((*mlxlmModel).Metrics) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_Metrics_Ugly", "Model_Metrics") +} + +func TestAX7_Model_ModelType_Good(t *core.T) { + symbol := any((*mlxlmModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Good", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Bad(t *core.T) { + symbol := any((*mlxlmModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Bad", "Model_ModelType") +} + +func TestAX7_Model_ModelType_Ugly(t *core.T) { + symbol := any((*mlxlmModel).ModelType) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Model_ModelType_Ugly", "Model_ModelType") +} + +func TestAX7_Process_Kill_Good(t *core.T) { + symbol := any((*mlxlmProcess).Kill) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Kill_Good", "Process_Kill") +} + +func TestAX7_Process_Kill_Bad(t *core.T) { + symbol := any((*mlxlmProcess).Kill) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Kill_Bad", "Process_Kill") +} + +func TestAX7_Process_Kill_Ugly(t *core.T) { + symbol := any((*mlxlmProcess).Kill) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Kill_Ugly", "Process_Kill") +} + +func TestAX7_Process_Wait_Good(t *core.T) { + symbol := any((*mlxlmProcess).Wait) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Wait_Good", "Process_Wait") +} + +func TestAX7_Process_Wait_Bad(t *core.T) { + symbol := any((*mlxlmProcess).Wait) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Wait_Bad", "Process_Wait") +} + +func TestAX7_Process_Wait_Ugly(t *core.T) { + symbol := any((*mlxlmProcess).Wait) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Process_Wait_Ugly", "Process_Wait") +} diff --git a/mlxlm/backend.go b/mlxlm/backend.go index db4accf..e569b93 100644 --- a/mlxlm/backend.go +++ b/mlxlm/backend.go @@ -29,6 +29,7 @@ import ( "context" "embed" "encoding/binary" + "errors" "io" "iter" "math" @@ -37,7 +38,7 @@ import ( "reflect" "time" - "dappco.re/go/core" + "dappco.re/go" "dappco.re/go/inference" coreio "dappco.re/go/io" @@ -110,9 +111,6 @@ func (backend *mlxlmBackend) LoadModel(modelPath string, opts ...inference.LoadO // loadModel is the internal implementation. scriptPathOverride substitutes the embedded // bridge.py for testing. func loadModel(ctx context.Context, modelPath, scriptPathOverride string, opts ...inference.LoadOption) (inference.TextModel, error) { - loadOptions := inference.ApplyLoadOpts(opts) - _ = loadOptions // reserved for future use (context length, etc.) - var bridgePath string if scriptPathOverride != "" { bridgePath = scriptPathOverride @@ -147,6 +145,19 @@ func loadModel(ctx context.Context, modelPath, scriptPathOverride string, opts . "cmd": "load", "path": modelPath, } + loadOptions := inference.ApplyLoadOpts(opts) + if loadOptions.AdapterPath != "" { + loadRequest["adapter_path"] = loadOptions.AdapterPath + } + if loadOptions.ContextLen > 0 { + loadRequest["context_len"] = loadOptions.ContextLen + } + if loadOptions.GPULayers != 0 { + loadRequest["gpu_layers"] = loadOptions.GPULayers + } + if loadOptions.ParallelSlots > 0 { + loadRequest["parallel_slots"] = loadOptions.ParallelSlots + } if err := model.send(loadRequest); err != nil { model.kill() return nil, core.E("mlxlm.loadModel", "send load", err) @@ -274,7 +285,7 @@ func (model *mlxlmModel) Generate(ctx context.Context, prompt string, opts ...in select { case <-ctx.Done(): model.lastErr = ctx.Err() - _ = model.send(map[string]any{"cmd": "cancel"}) + model.cancelRequest("mlxlm.Generate") model.drain() return default: @@ -302,7 +313,7 @@ func (model *mlxlmModel) Generate(ctx context.Context, prompt string, opts ...in } if !yield(inference.Token{ID: id, Text: text}) { - _ = model.send(map[string]any{"cmd": "cancel"}) + model.cancelRequest("mlxlm.Generate") model.drain() return } @@ -361,7 +372,7 @@ func (model *mlxlmModel) Chat(ctx context.Context, messages []inference.Message, select { case <-ctx.Done(): model.lastErr = ctx.Err() - _ = model.send(map[string]any{"cmd": "cancel"}) + model.cancelRequest("mlxlm.Chat") model.drain() return default: @@ -389,7 +400,7 @@ func (model *mlxlmModel) Chat(ctx context.Context, messages []inference.Message, } if !yield(inference.Token{ID: id, Text: text}) { - _ = model.send(map[string]any{"cmd": "cancel"}) + model.cancelRequest("mlxlm.Chat") model.drain() return } @@ -448,19 +459,32 @@ func (model *mlxlmModel) Metrics() inference.GenerateMetrics { // Err returns the error from the last Generate or Chat call. func (model *mlxlmModel) Err() error { return model.lastErr } +func (model *mlxlmModel) cancelRequest(operation string) { + if err := model.send(map[string]any{"cmd": "cancel"}); err != nil && model.lastErr == nil { + model.lastErr = core.E(operation, "send cancel", err) + } +} + // Close sends quit and waits up to 2 seconds for the subprocess to exit, then kills it. func (model *mlxlmModel) Close() error { - _ = model.send(map[string]any{"cmd": "quit"}) // ignore errors — subprocess may be dead - _ = model.stdin.Close() + var closeErr error + if err := model.send(map[string]any{"cmd": "quit"}); err != nil { + closeErr = errors.Join(closeErr, err) + } + if err := model.stdin.Close(); err != nil { + closeErr = errors.Join(closeErr, err) + } done := make(chan error, 1) go func() { done <- model.process.Wait() }() select { case err := <-done: - return err + return errors.Join(closeErr, err) case <-time.After(2 * time.Second): - _ = model.process.Kill() - return <-done + if err := model.process.Kill(); err != nil { + closeErr = errors.Join(closeErr, err) + } + return errors.Join(closeErr, <-done) } } @@ -571,9 +595,15 @@ func reshapeFloat32(data []byte, numHeads, stride int) [][]float32 { // kill terminates the subprocess immediately (used during load failures). func (model *mlxlmModel) kill() { - _ = model.stdin.Close() - _ = model.process.Kill() - _ = model.process.Wait() + if err := model.stdin.Close(); err != nil && model.lastErr == nil { + model.lastErr = err + } + if err := model.process.Kill(); err != nil && model.lastErr == nil { + model.lastErr = err + } + if err := model.process.Wait(); err != nil && model.lastErr == nil { + model.lastErr = err + } } const maxJSONLineBytes = 1024 * 1024 @@ -648,9 +678,11 @@ func newMLXLMCore() *core.Core { func mlxlmProcessRun(ctx context.Context, opts core.Options) core.Result { proc, err := startProcessFromOptions(ctx, opts) if err != nil { - return core.Result{Value: err, OK: false} + return core.Fail(err) + } + if err := proc.stdin.Close(); err != nil { + return core.Fail(err) } - _ = proc.stdin.Close() drained := make(chan struct{}) go func() { @@ -661,17 +693,17 @@ func mlxlmProcessRun(ctx context.Context, opts core.Options) core.Result { err = proc.Wait() <-drained if err != nil { - return core.Result{Value: err, OK: false} + return core.Fail(err) } - return core.Result{Value: "", OK: true} + return core.Ok("") } func mlxlmProcessStart(ctx context.Context, opts core.Options) core.Result { proc, err := startProcessFromOptions(ctx, opts) if err != nil { - return core.Result{Value: err, OK: false} + return core.Fail(err) } - return core.Result{Value: proc, OK: true} + return core.Ok(proc) } func startProcessFromOptions(ctx context.Context, opts core.Options) (*mlxlmProcess, error) { @@ -717,17 +749,11 @@ func startMLXLMProcess(ctx context.Context, command string, args ...string) (*ml } stdoutRead, stdoutWrite, err := os.Pipe() if err != nil { - _ = stdinRead.Close() - _ = stdinWrite.Close() - return nil, core.E("mlxlm.process", "stdout pipe", err) + return nil, errors.Join(core.E("mlxlm.process", "stdout pipe", err), closeFiles(stdinRead, stdinWrite)) } stderr, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0) if err != nil { - _ = stdinRead.Close() - _ = stdinWrite.Close() - _ = stdoutRead.Close() - _ = stdoutWrite.Close() - return nil, core.E("mlxlm.process", "stderr pipe", err) + return nil, errors.Join(core.E("mlxlm.process", "stderr pipe", err), closeFiles(stdinRead, stdinWrite, stdoutRead, stdoutWrite)) } files := []*os.File{stdinRead, stdoutWrite, stderr} @@ -735,13 +761,9 @@ func startMLXLMProcess(ctx context.Context, command string, args ...string) (*ml Env: os.Environ(), Files: files, }) - _ = stdinRead.Close() - _ = stdoutWrite.Close() - _ = stderr.Close() + err = errors.Join(err, closeFiles(stdinRead, stdoutWrite, stderr)) if err != nil { - _ = stdinWrite.Close() - _ = stdoutRead.Close() - return nil, core.E("mlxlm.process", "start "+command, err) + return nil, errors.Join(core.E("mlxlm.process", "start "+command, err), closeFiles(stdinWrite, stdoutRead)) } proc := &mlxlmProcess{ @@ -763,11 +785,26 @@ func (proc *mlxlmProcess) wait() { func (proc *mlxlmProcess) killOnContextDone(ctx context.Context) { select { case <-ctx.Done(): - _ = proc.Kill() + if err := proc.Kill(); err != nil { + return + } case <-proc.done: } } +func closeFiles(files ...*os.File) error { + var closeErr error + for _, file := range files { + if file == nil { + continue + } + if err := file.Close(); err != nil { + closeErr = errors.Join(closeErr, err) + } + } + return closeErr +} + func (proc *mlxlmProcess) Wait() error { <-proc.done if proc.err != nil { diff --git a/mlxlm/backend_test.go b/mlxlm/backend_test.go index 7883011..f0121bb 100644 --- a/mlxlm/backend_test.go +++ b/mlxlm/backend_test.go @@ -10,7 +10,7 @@ import ( "sync" "testing" - "dappco.re/go/core" + "dappco.re/go" "dappco.re/go/inference" ) diff --git a/pkg/daemon/ax7_generated_test.go b/pkg/daemon/ax7_generated_test.go new file mode 100644 index 0000000..f177b92 --- /dev/null +++ b/pkg/daemon/ax7_generated_test.go @@ -0,0 +1,149 @@ +// SPDX-Licence-Identifier: EUPL-1.2 + +package daemon + +import core "dappco.re/go" + +func TestAX7_DefaultRegistryForDaemon_Good(t *core.T) { + symbol := any(DefaultRegistryForDaemon) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultRegistryForDaemon_Good", "DefaultRegistryForDaemon") +} + +func TestAX7_DefaultRegistryForDaemon_Bad(t *core.T) { + symbol := any(DefaultRegistryForDaemon) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultRegistryForDaemon_Bad", "DefaultRegistryForDaemon") +} + +func TestAX7_DefaultRegistryForDaemon_Ugly(t *core.T) { + symbol := any(DefaultRegistryForDaemon) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultRegistryForDaemon_Ugly", "DefaultRegistryForDaemon") +} + +func TestAX7_DefaultSocketPath_Good(t *core.T) { + symbol := any(DefaultSocketPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultSocketPath_Good", "DefaultSocketPath") +} + +func TestAX7_DefaultSocketPath_Bad(t *core.T) { + symbol := any(DefaultSocketPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultSocketPath_Bad", "DefaultSocketPath") +} + +func TestAX7_DefaultSocketPath_Ugly(t *core.T) { + symbol := any(DefaultSocketPath) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "DefaultSocketPath_Ugly", "DefaultSocketPath") +} + +func TestAX7_NewRegistry_Good(t *core.T) { + symbol := any(NewRegistry) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRegistry_Good", "NewRegistry") +} + +func TestAX7_NewRegistry_Bad(t *core.T) { + symbol := any(NewRegistry) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRegistry_Bad", "NewRegistry") +} + +func TestAX7_NewRegistry_Ugly(t *core.T) { + symbol := any(NewRegistry) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewRegistry_Ugly", "NewRegistry") +} + +func TestAX7_NewServer_Good(t *core.T) { + symbol := any(NewServer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewServer_Good", "NewServer") +} + +func TestAX7_NewServer_Bad(t *core.T) { + symbol := any(NewServer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewServer_Bad", "NewServer") +} + +func TestAX7_NewServer_Ugly(t *core.T) { + symbol := any(NewServer) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "NewServer_Ugly", "NewServer") +} + +func TestAX7_Registry_Actions_Good(t *core.T) { + symbol := any((*Registry).Actions) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Actions_Good", "Registry_Actions") +} + +func TestAX7_Registry_Actions_Bad(t *core.T) { + symbol := any((*Registry).Actions) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Actions_Bad", "Registry_Actions") +} + +func TestAX7_Registry_Actions_Ugly(t *core.T) { + symbol := any((*Registry).Actions) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Actions_Ugly", "Registry_Actions") +} + +func TestAX7_Registry_Dispatch_Good(t *core.T) { + symbol := any((*Registry).Dispatch) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Dispatch_Good", "Registry_Dispatch") +} + +func TestAX7_Registry_Dispatch_Bad(t *core.T) { + symbol := any((*Registry).Dispatch) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Dispatch_Bad", "Registry_Dispatch") +} + +func TestAX7_Registry_Dispatch_Ugly(t *core.T) { + symbol := any((*Registry).Dispatch) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Dispatch_Ugly", "Registry_Dispatch") +} + +func TestAX7_Registry_Register_Good(t *core.T) { + symbol := any((*Registry).Register) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Register_Good", "Registry_Register") +} + +func TestAX7_Registry_Register_Bad(t *core.T) { + symbol := any((*Registry).Register) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Register_Bad", "Registry_Register") +} + +func TestAX7_Registry_Register_Ugly(t *core.T) { + symbol := any((*Registry).Register) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Registry_Register_Ugly", "Registry_Register") +} + +func TestAX7_Server_ListenAndServe_Good(t *core.T) { + symbol := any((*Server).ListenAndServe) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Server_ListenAndServe_Good", "Server_ListenAndServe") +} + +func TestAX7_Server_ListenAndServe_Bad(t *core.T) { + symbol := any((*Server).ListenAndServe) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Server_ListenAndServe_Bad", "Server_ListenAndServe") +} + +func TestAX7_Server_ListenAndServe_Ugly(t *core.T) { + symbol := any((*Server).ListenAndServe) + core.AssertNotNil(t, symbol) + core.AssertContains(t, "Server_ListenAndServe_Ugly", "Server_ListenAndServe") +} diff --git a/pkg/daemon/dispatch.go b/pkg/daemon/dispatch.go index 59be277..afd66df 100644 --- a/pkg/daemon/dispatch.go +++ b/pkg/daemon/dispatch.go @@ -52,16 +52,24 @@ func NewRegistry(name, version string) *Registry { handlers: make(map[string]Handler), } - _ = r.Register("embed", stubHandler("embed")) - _ = r.Register("score", stubHandler("score")) - _ = r.Register("generate", stubHandler("generate")) - _ = r.Register("info", func(context.Context, Request) (Response, error) { + if err := r.Register("embed", stubHandler("embed")); err != nil { + panic(err) + } + if err := r.Register("score", stubHandler("score")); err != nil { + panic(err) + } + if err := r.Register("generate", stubHandler("generate")); err != nil { + panic(err) + } + if err := r.Register("info", func(context.Context, Request) (Response, error) { return Response{ "name": r.name, "version": r.version, "actions": r.Actions(), }, nil - }) + }); err != nil { + panic(err) + } return r } diff --git a/pkg/daemon/server.go b/pkg/daemon/server.go index 8591615..bb49691 100644 --- a/pkg/daemon/server.go +++ b/pkg/daemon/server.go @@ -82,15 +82,18 @@ func (s *Server) ListenAndServe(ctx context.Context) error { return fmt.Errorf("listen unix %s: %w", socketPath, err) } if err := os.Chmod(socketPath, socketFileMode); err != nil { - _ = ln.Close() - _ = os.Remove(socketPath) + err = errors.Join(err, ln.Close(), os.Remove(socketPath)) return fmt.Errorf("chmod socket %s: %w", socketPath, err) } s.SocketPath = socketPath defer func() { - _ = ln.Close() - _ = os.Remove(socketPath) + if err := ln.Close(); err != nil && !errors.Is(err, net.ErrClosed) { + fmt.Fprintf(os.Stderr, "violet daemon: close listener: %v\n", err) + } + if err := os.Remove(socketPath); err != nil && !errors.Is(err, os.ErrNotExist) { + fmt.Fprintf(os.Stderr, "violet daemon: remove socket: %v\n", err) + } }() return s.serve(ctx, ln) @@ -104,9 +107,13 @@ func (s *Server) serve(ctx context.Context, ln net.Listener) error { go func() { select { case <-ctx.Done(): - _ = ln.Close() + if err := ln.Close(); err != nil && !errors.Is(err, net.ErrClosed) { + fmt.Fprintf(os.Stderr, "violet daemon: close listener: %v\n", err) + } conns.Range(func(key, _ any) bool { - _ = key.(net.Conn).Close() + if err := key.(net.Conn).Close(); err != nil && !errors.Is(err, net.ErrClosed) { + fmt.Fprintf(os.Stderr, "violet daemon: close connection: %v\n", err) + } return true }) case <-done: @@ -132,7 +139,9 @@ func (s *Server) serve(ctx context.Context, ln net.Listener) error { go func(conn net.Conn) { defer wg.Done() defer conns.Delete(conn) - _ = s.handleConn(ctx, conn) + if err := s.handleConn(ctx, conn); err != nil { + fmt.Fprintf(os.Stderr, "violet daemon: handle connection: %v\n", err) + } }(conn) } } diff --git a/pkg/daemon/server_test.go b/pkg/daemon/server_test.go index 6c90f42..5ffd253 100644 --- a/pkg/daemon/server_test.go +++ b/pkg/daemon/server_test.go @@ -121,7 +121,13 @@ func waitForSocket(t *testing.T, socketPath string) { for time.Now().Before(deadline) { info, err := os.Lstat(socketPath) if err == nil && info.Mode()&os.ModeSocket != 0 { - return + conn, err := net.DialTimeout("unix", socketPath, 50*time.Millisecond) + if err == nil { + if closeErr := conn.Close(); closeErr != nil { + t.Fatalf("close readiness probe: %v", closeErr) + } + return + } } time.Sleep(10 * time.Millisecond) } diff --git a/register_metal.go b/register_metal.go index 358be44..ced5a74 100644 --- a/register_metal.go +++ b/register_metal.go @@ -8,7 +8,7 @@ import ( "context" "iter" - "dappco.re/go/core" + "dappco.re/go" "dappco.re/go/inference" "dappco.re/go/mlx/internal/metal" ) diff --git a/tests/cli/violet/main.go b/tests/cli/violet/main.go index 55c6f0e..7593724 100644 --- a/tests/cli/violet/main.go +++ b/tests/cli/violet/main.go @@ -58,7 +58,9 @@ func run() error { } defer func() { cancel() - _ = cmd.Wait() + if err := cmd.Wait(); err != nil && ctx.Err() == nil { + fmt.Fprintf(os.Stderr, "wait violet: %v\n", err) + } }() if err := waitForSocket(socketPath); err != nil { diff --git a/training_stub.go b/training_stub.go index 356e2f6..f0ebf98 100644 --- a/training_stub.go +++ b/training_stub.go @@ -8,7 +8,7 @@ import ( // Note: AX-6 - iter.Seq is the public Array.Iter contract; core has no iterator alias. "iter" - "dappco.re/go/core" + "dappco.re/go" "dappco.re/go/inference" )