From 6f3918c6b956de996d6a8e673d734789a99bd50e Mon Sep 17 00:00:00 2001 From: water <672684719@qq.com> Date: Fri, 24 Jul 2026 23:58:56 +0800 Subject: [PATCH] feat: Java/Kotlin lh_standard_adapter for Maven Central MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implement the LongHun Standard Adapter in Java with Kotlin-friendly annotations. Full port of the Python reference implementation. - LongHunAdapter: main wrapper class (wrap, validate, getSchemas) - DNAGenerator: v∞ DNA traceability with stem-branch + I Ching - AuditWrapper: seven-factor behavioral audit logging - Validator: full validation (DNA regex, audit structure, UID, sigma) - ValidationResult: immutable result with errors/warnings/summary - Schemas: JSON Schema definitions for DNA and Audit formats - 99 JUnit 5 tests (4 test classes) - Maven project with Jackson, JUnit 5, jsr305 - Javadoc on all public methods - Kotlin-friendly (null-safety annotations) Closes #4 --- adapters/java/LICENSE | 437 ++++++++++++++++++ adapters/java/README.md | 174 +++++++ adapters/java/pom.xml | 112 +++++ .../java/cn/uid9622/longhun/AuditWrapper.java | 268 +++++++++++ .../java/cn/uid9622/longhun/DNAGenerator.java | 259 +++++++++++ .../cn/uid9622/longhun/LongHunAdapter.java | 280 +++++++++++ .../main/java/cn/uid9622/longhun/Schemas.java | 234 ++++++++++ .../cn/uid9622/longhun/ValidationResult.java | 117 +++++ .../java/cn/uid9622/longhun/Validator.java | 332 +++++++++++++ .../java/cn/uid9622/longhun/package-info.java | 17 + .../cn/uid9622/longhun/AuditWrapperTest.java | 299 ++++++++++++ .../cn/uid9622/longhun/DNAGeneratorTest.java | 232 ++++++++++ .../uid9622/longhun/LongHunAdapterTest.java | 319 +++++++++++++ .../cn/uid9622/longhun/ValidatorTest.java | 339 ++++++++++++++ 14 files changed, 3419 insertions(+) create mode 100644 adapters/java/LICENSE create mode 100644 adapters/java/README.md create mode 100644 adapters/java/pom.xml create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/AuditWrapper.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/DNAGenerator.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/LongHunAdapter.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/Schemas.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/ValidationResult.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/Validator.java create mode 100644 adapters/java/src/main/java/cn/uid9622/longhun/package-info.java create mode 100644 adapters/java/src/test/java/cn/uid9622/longhun/AuditWrapperTest.java create mode 100644 adapters/java/src/test/java/cn/uid9622/longhun/DNAGeneratorTest.java create mode 100644 adapters/java/src/test/java/cn/uid9622/longhun/LongHunAdapterTest.java create mode 100644 adapters/java/src/test/java/cn/uid9622/longhun/ValidatorTest.java diff --git a/adapters/java/LICENSE b/adapters/java/LICENSE new file mode 100644 index 0000000..af1380a --- /dev/null +++ b/adapters/java/LICENSE @@ -0,0 +1,437 @@ +1|Attribution-NonCommercial-ShareAlike 4.0 International +2| +3|======================================================================= +4| +5|Creative Commons Corporation ("Creative Commons") is not a law firm and +6|does not provide legal services or legal advice. Distribution of +7|Creative Commons public licenses does not create a lawyer-client or +8|other relationship. Creative Commons makes its licenses and related +9|information available on an "as-is" basis. Creative Commons gives no +10|warranties regarding its licenses, any material licensed under their +11|terms and conditions, or any related information. Creative Commons +12|disclaims all liability for damages resulting from their use to the +13|fullest extent possible. +14| +15|Using Creative Commons Public Licenses +16| +17|Creative Commons public licenses provide a standard set of terms and +18|conditions that creators and other rights holders may use to share +19|original works of authorship and other material subject to copyright +20|and certain other rights specified in the public license below. The +21|following considerations are for informational purposes only, are not +22|exhaustive, and do not form part of our licenses. +23| +24| Considerations for licensors: Our public licenses are +25| intended for use by those authorized to give the public +26| permission to use material in ways otherwise restricted by +27| copyright and certain other rights. Our licenses are +28| irrevocable. Licensors should read and understand the terms +29| and conditions of the license they choose before applying it. +30| Licensors should also secure all rights necessary before +31| applying our licenses so that the public can reuse the +32| material as expected. Licensors should clearly mark any +33| material not subject to the license. This includes other CC- +34| licensed material, or material used under an exception or +35| limitation to copyright. More considerations for licensors: +36| wiki.creativecommons.org/Considerations_for_licensors +37| +38| Considerations for the public: By using one of our public +39| licenses, a licensor grants the public permission to use the +40| licensed material under specified terms and conditions. If +41| the licensor's permission is not necessary for any reason--for +42| example, because of any applicable exception or limitation to +43| copyright--then that use is not regulated by the license. Our +44| licenses grant only permissions under copyright and certain +45| other rights that a licensor has authority to grant. Use of +46| the licensed material may still be restricted for other +47| reasons, including because others have copyright or other +48| rights in the material. A licensor may make special requests, +49| such as asking that all changes be marked or described. +50| Although not required by our licenses, you are encouraged to +51| respect those requests where reasonable. More considerations +52| for the public: +53| wiki.creativecommons.org/Considerations_for_licensees +54| +55|======================================================================= +56| +57|Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International +58|Public License +59| +60|By exercising the Licensed Rights (defined below), You accept and agree +61|to be bound by the terms and conditions of this Creative Commons +62|Attribution-NonCommercial-ShareAlike 4.0 International Public License +63|("Public License"). To the extent this Public License may be +64|interpreted as a contract, You are granted the Licensed Rights in +65|consideration of Your acceptance of these terms and conditions, and the +66|Licensor grants You such rights in consideration of benefits the +67|Licensor receives from making the Licensed Material available under +68|these terms and conditions. +69| +70| +71|Section 1 -- Definitions. +72| +73| a. Adapted Material means material subject to Copyright and Similar +74| Rights that is derived from or based upon the Licensed Material +75| and in which the Licensed Material is translated, altered, +76| arranged, transformed, or otherwise modified in a manner requiring +77| permission under the Copyright and Similar Rights held by the +78| Licensor. For purposes of this Public License, where the Licensed +79| Material is a musical work, performance, or sound recording, +80| Adapted Material is always produced where the Licensed Material is +81| synched in timed relation with a moving image. +82| +83| b. Adapter's License means the license You apply to Your Copyright +84| and Similar Rights in Your contributions to Adapted Material in +85| accordance with the terms and conditions of this Public License. +86| +87| c. BY-NC-SA Compatible License means a license listed at +88| creativecommons.org/compatiblelicenses, approved by Creative +89| Commons as essentially the equivalent of this Public License. +90| +91| d. Copyright and Similar Rights means copyright and/or similar rights +92| closely related to copyright including, without limitation, +93| performance, broadcast, sound recording, and Sui Generis Database +94| Rights, without regard to how the rights are labeled or +95| categorized. For purposes of this Public License, the rights +96| specified in Section 2(b)(1)-(2) are not Copyright and Similar +97| Rights. +98| +99| e. Effective Technological Measures means those measures that, in the +100| absence of proper authority, may not be circumvented under laws +101| fulfilling obligations under Article 11 of the WIPO Copyright +102| Treaty adopted on December 20, 1996, and/or similar international +103| agreements. +104| +105| f. Exceptions and Limitations means fair use, fair dealing, and/or +106| any other exception or limitation to Copyright and Similar Rights +107| that applies to Your use of the Licensed Material. +108| +109| g. License Elements means the license attributes listed in the name +110| of a Creative Commons Public License. The License Elements of this +111| Public License are Attribution, NonCommercial, and ShareAlike. +112| +113| h. Licensed Material means the artistic or literary work, database, +114| or other material to which the Licensor applied this Public +115| License. +116| +117| i. Licensed Rights means the rights granted to You subject to the +118| terms and conditions of this Public License, which are limited to +119| all Copyright and Similar Rights that apply to Your use of the +120| Licensed Material and that the Licensor has authority to license. +121| +122| j. Licensor means the individual(s) or entity(ies) granting rights +123| under this Public License. +124| +125| k. NonCommercial means not primarily intended for or directed towards +126| commercial advantage or monetary compensation. For purposes of +127| this Public License, the exchange of the Licensed Material for +128| other material subject to Copyright and Similar Rights by digital +129| file-sharing or similar means is NonCommercial provided there is +130| no payment of monetary compensation in connection with the +131| exchange. +132| +133| l. Share means to provide material to the public by any means or +134| process that requires permission under the Licensed Rights, such +135| as reproduction, public display, public performance, distribution, +136| dissemination, communication, or importation, and to make material +137| available to the public including in ways that members of the +138| public may access the material from a place and at a time +139| individually chosen by them. +140| +141| m. Sui Generis Database Rights means rights other than copyright +142| resulting from Directive 96/9/EC of the European Parliament and of +143| the Council of 11 March 1996 on the legal protection of databases, +144| as amended and/or succeeded, as well as other essentially +145| equivalent rights anywhere in the world. +146| +147| n. You means the individual or entity exercising the Licensed Rights +148| under this Public License. Your has a corresponding meaning. +149| +150| +151|Section 2 -- Scope. +152| +153| a. License grant. +154| +155| 1. Subject to the terms and conditions of this Public License, +156| the Licensor hereby grants You a worldwide, royalty-free, +157| non-sublicensable, non-exclusive, irrevocable license to +158| exercise the Licensed Rights in the Licensed Material to: +159| +160| a. reproduce and Share the Licensed Material, in whole or +161| in part, for NonCommercial purposes only; and +162| +163| b. produce, reproduce, and Share Adapted Material for +164| NonCommercial purposes only. +165| +166| 2. Exceptions and Limitations. For the avoidance of doubt, where +167| Exceptions and Limitations apply to Your use, this Public +168| License does not apply, and You do not need to comply with +169| its terms and conditions. +170| +171| 3. Term. The term of this Public License is specified in Section +172| 6(a). +173| +174| 4. Media and formats; technical modifications allowed. The +175| Licensor authorizes You to exercise the Licensed Rights in +176| all media and formats whether now known or hereafter created, +177| and to make technical modifications necessary to do so. The +178| Licensor waives and/or agrees not to assert any right or +179| authority to forbid You from making technical modifications +180| necessary to exercise the Licensed Rights, including +181| technical modifications necessary to circumvent Effective +182| Technological Measures. For purposes of this Public License, +183| simply making modifications authorized by this Section 2(a) +184| (4) never produces Adapted Material. +185| +186| 5. Downstream recipients. +187| +188| a. Offer from the Licensor -- Licensed Material. Every +189| recipient of the Licensed Material automatically +190| receives an offer from the Licensor to exercise the +191| Licensed Rights under the terms and conditions of this +192| Public License. +193| +194| b. Additional offer from the Licensor -- Adapted Material. +195| Every recipient of Adapted Material from You +196| automatically receives an offer from the Licensor to +197| exercise the Licensed Rights in the Adapted Material +198| under the conditions of the Adapter's License You apply. +199| +200| c. No downstream restrictions. You may not offer or impose +201| any additional or different terms or conditions on, or +202| apply any Effective Technological Measures to, the +203| Licensed Material if doing so restricts exercise of the +204| Licensed Rights by any recipient. +205| +206| 6. No endorsement. Nothing in this Public License constitutes or +207| may be construed as permission to assert or imply that You +208| are, or that Your use of the Licensed Material is, connected +209| with, or sponsored, or endorsed by, or granted official status +210| by, the Licensor or others designated to receive attribution +211| as provided in Section 3(a)(1)(A)(i). +212| +213| b. Other rights. +214| +215| 1. Moral rights, such as the right of integrity, are not +216| licensed under this Public License, nor are publicity, +217| privacy, and/or other similar personality rights; however, to +218| the extent possible, the Licensor waives and/or agrees not to +219| assert any such rights held by the Licensor to the limited +220| extent necessary to allow You to exercise the Licensed +221| Rights, but not otherwise. +222| +223| 2. Patent and trademark rights are not licensed under this +224| Public License. +225| +226| 3. To the extent possible, the Licensor waives any right to +227| collect royalties from You for the exercise of the Licensed +228| Rights, whether directly or through a collecting society under +229| any voluntary or waivable statutory or compulsory licensing +230| scheme. In all other cases the Licensor expressly reserves +231| any right to collect such royalties, including when the +232| Licensed Material is used other than for NonCommercial +233| purposes. +234| +235| +236|Section 3 -- License Conditions. +237| +238|Your exercise of the Licensed Rights is expressly made subject to the +239|following conditions. +240| +241| a. Attribution. +242| +243| 1. If You Share the Licensed Material (including in modified +244| form), You must: +245| +246| a. retain the following if it is supplied by the Licensor +247| with the Licensed Material: +248| +249| i. identification of the creator(s) of the Licensed +250| Material and any others designated to receive +251| attribution, in any reasonable manner requested by +252| the Licensor (including by pseudonym if designated); +253| +254| ii. a copyright notice; +255| +256| iii. a notice that refers to this Public License; +257| +258| iv. a notice that refers to the disclaimer of +259| warranties; +260| +261| v. a URI or hyperlink to the Licensed Material to the +262| extent reasonably practicable; +263| +264| b. indicate if You modified the Licensed Material and +265| retain an indication of any previous modifications; and +266| +267| c. indicate the Licensed Material is licensed under this +268| Public License, and include the text of, or the URI or +269| hyperlink to, this Public License. +270| +271| 2. You may satisfy the conditions in Section 3(a)(1) in any +272| reasonable manner based on the medium, means, and context in +273| which You Share the Licensed Material. For example, it may be +274| reasonable to satisfy the conditions by providing a URI or +275| hyperlink to a resource that includes the required +276| information. +277| +278| 3. If requested by the Licensor, You must remove any of the +279| information required by Section 3(a)(1)(A) to the extent +280| reasonably practicable. +281| +282| b. ShareAlike. +283| +284| In addition to the conditions in Section 3(a), if You Share +285| Adapted Material You produce, the following conditions also apply. +286| +287| 1. The Adapter's License You apply must be a Creative Commons +288| license with the same License Elements, this version or +289| later, or a BY-NC-SA Compatible License. +290| +291| 2. You must include the text of, or the URI or hyperlink to, the +292| Adapter's License You apply. You may satisfy this condition +293| in any reasonable manner based on the medium, means, and +294| context in which You Share Adapted Material. +295| +296| 3. You may not offer or impose any additional or different terms +297| or conditions on, or apply any Effective Technological +298| Measures to, Adapted Material that restrict exercise of the +299| rights granted under the Adapter's License You apply. +300| +301| +302|Section 4 -- Sui Generis Database Rights. +303| +304|Where the Licensed Rights include Sui Generis Database Rights that +305|apply to Your use of the Licensed Material: +306| +307| a. for the avoidance of doubt, Section 2(a)(1) grants You the right +308| to extract, reuse, reproduce, and Share all or a substantial +309| portion of the contents of the database for NonCommercial purposes +310| only; +311| +312| b. if You include all or a substantial portion of the database +313| contents in a database in which You have Sui Generis Database +314| Rights, then the database in which You have Sui Generis Database +315| Rights (but not its individual contents) is Adapted Material, +316| +317| including for purposes of Section 3(b); and +318| c. You must comply with the conditions in Section 3(a) if You Share +319| all or a substantial portion of the contents of the database. +320| +321|For the avoidance of doubt, this Section 4 supplements and does not +322|replace Your obligations under this Public License where the Licensed +323|Rights include other Copyright and Similar Rights. +324| +325| +326|Section 5 -- Disclaimer of Warranties and Limitation of Liability. +327| +328| a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE +329| EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS +330| AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF +331| ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, +332| IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, +333| WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR +334| PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, +335| ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT +336| KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT +337| FULLY ALLOWED IN PART OR IN WHOLE, THIS DISCLAIMER MAY NOT APPLY +338| TO YOU. +339| +340| b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE +341| TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, +342| NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, +343| INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, +344| COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR +345| USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN +346| ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR +347| DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT FULLY ALLOWED IN +348| PART OR IN WHOLE, THIS LIMITATION MAY NOT APPLY TO YOU. +349| +350| c. The disclaimer of warranties and limitation of liability provided +351| above shall be interpreted in a manner that, to the extent +352| possible, most closely approximates an absolute disclaimer and +353| waiver of all liability. +354| +355| +356|Section 6 -- Term and Termination. +357| +358| a. This Public License applies for the term of the Copyright and +359| Similar Rights licensed here. However, if You fail to comply with +360| this Public License, then Your rights under this Public License +361| terminate automatically. +362| +363| b. Where Your right to use the Licensed Material has terminated under +364| Section 6(a), it reinstates: +365| +366| 1. automatically as of the date the violation is cured, provided +367| it is cured within 30 days of Your discovery of the +368| violation; or +369| +370| 2. upon express reinstatement by the Licensor. +371| +372| For the avoidance of doubt, this Section 6(b) does not affect any +373| right the Licensor may have to seek remedies for Your violations +374| of this Public License. +375| +376| c. For the avoidance of doubt, the Licensor may also offer the +377| Licensed Material under separate terms or conditions or stop +378| distributing the Licensed Material at any time; however, doing so +379| will not terminate this Public License. +380| +381| d. Sections 1, 5, 6, 7, and 8 survive termination of this Public +382| License. +383| +384| +385|Section 7 -- Other Terms and Conditions. +386| +387| a. The Licensor shall not be bound by any additional or different +388| terms or conditions communicated by You unless expressly agreed. +389| +390| b. Any arrangements, understandings, or agreements regarding the +391| Licensed Material not stated herein are separate from and +392| independent of the terms and conditions of this Public License. +393| +394| +395|Section 8 -- Interpretation. +396| +397| a. For the avoidance of doubt, this Public License does not, and +398| shall not be interpreted to, reduce, limit, restrict, or impose +399| conditions on any use of the Licensed Material that could lawfully +400| be made without permission under this Public License. +401| +402| b. To the extent possible, if any provision of this Public License is +403| held to be unenforceable, it shall be automatically reformed to the +404| minimum extent necessary to make it enforceable. If the provision +405| cannot be reformed, it shall be severed from this Public License +406| without affecting the enforceability of the remaining terms and +407| conditions. +408| +409| c. No term or condition of this Public License will be waived and no +410| failure to comply consented to unless expressly agreed to by the +411| Licensor. +412| +413| d. Nothing in this Public License constitutes or may be interpreted +414| as a limitation upon, or waiver of, any privileges and immunities +415| that apply to the Licensor or You, including from the legal +416| processes of any jurisdiction or authority. +417| +418|======================================================================= +419| +420|Creative Commons is not a party to its public +421|licenses. Notwithstanding, Creative Commons may elect to apply one of +422|its public licenses to material it publishes and in those instances +423|will be considered the "Licensor." The text of the Creative Commons +424|public licenses is dedicated to the public domain under the CC0 Public +425|Domain Dedication. Except for the limited purpose of indicating that +426|material is shared under a Creative Commons public license or as +427|otherwise permitted by the Creative Commons policies published at +428|creativecommons.org/policies, Creative Commons does not authorize the +429|use of the trademark "Creative Commons" or any other trademark or logo +430|of Creative Commons without its prior written consent including, +431|without limitation, in connection with any unauthorized modifications +432|to any of its public licenses or any other arrangements, +433|understandings, or agreements concerning use of licensed material. For +434|the avoidance of doubt, this paragraph does not form part of the +435|public licenses. +436| +437|======================================================================= \ No newline at end of file diff --git a/adapters/java/README.md b/adapters/java/README.md new file mode 100644 index 0000000..fb94af0 --- /dev/null +++ b/adapters/java/README.md @@ -0,0 +1,174 @@ +1|# LongHun Standard Adapter — Java / Kotlin +2| +3|> DNA: `#LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-ADAPTER-JAVA-v1.0.0` +4|> Author: LongHun Core · UID9622 · 龍芯北辰 +5|> License: [CC BY-NC-SA 4.0](LICENSE) +6|> Java Version: 8+ (JDK 1.8 compatible) +7| +8|**Open the standard. Guard the engine.** +9| +10|This is the Java/Kotlin implementation of the LongHun Standard Adapter. +11|It wraps JSON payloads with DNA traceability codes and seven-factor behavioral audit metadata, +12|following the [AI Traceability and Audit Protocol v1.0](../docs/AI-Traceability-Audit-Protocol-v1.0.md). +13| +14|## Features +15| +16|- ✅ **DNA Traceability (v∞ format)** — SHA-256 anchored, stem-branch + I Ching hexagram codes +17|- ✅ **Seven-Factor Behavioral Audit** — P, F, T, E, C, R, A, X, Y, Z signature +18|- ✅ **Behavior Pattern Classification** — 5 patterns (StableDisciplined, DefensiveDefaulter, etc.) +19|- ✅ **Three-Color Audit** — 🟢 Green, 🟡 Yellow, 🔴 Red +20|- ✅ **Bilingual Labels** — Chinese + English behavior labels +21|- ✅ **Full Validation** — DNA regex, audit structure, signature values, UID consistency +22|- ✅ **Kotlin-Friendly** — Null-safety annotations (`@Nonnull`, `@Nullable`), immutable data classes +23|- ✅ **72+ JUnit 5 Tests** — Comprehensive coverage +24|- ✅ **Java 8 Compatible** — Works with JDK 1.8+ +25| +26|## Maven +27| +28|Add this dependency to your `pom.xml`: +29| +30|```xml +31| +32| cn.uid9622.longhun +33| lh-standard-adapter +34| 1.0.0 +35| +36|``` +37| +38|## Java Usage +39| +40|### Basic Wrapping +41| +42|```java +43|import cn.uid9622.longhun.LongHunAdapter; +44|import cn.uid9622.longhun.ValidationResult; +45|import com.fasterxml.jackson.databind.node.ObjectNode; +46| +47|LongHunAdapter adapter = new LongHunAdapter("9622", "HM-9622-001"); +48| +49|// Wrap any JSON-serializable data +50|ObjectNode result = adapter.wrap( +51| Map.of("code", "print('hello')"), +52| "code", +53| "P04-Luban" +54|); +55| +56|// Access the DNA traceability code +57|String dna = result.get("dna").asText(); +58|// → "#LongHun⚡️BingWu·GuiWei·JiaZi·WeiShi·䷾JiJi-ADAPTER-CODE-WRAP-V1.0-a3f8c1d9" +59| +60|// Access the audit metadata +61|String pattern = result.get("audit").get("behavior_pattern").asText(); +62|// → "MODE-StableDisciplined" +63| +64|// Validate the wrapped payload +65|ValidationResult validation = adapter.validate(result); +66|if (validation.isValid()) { +67| System.out.println("✅ Valid: " + validation.getSummary()); +68|} +69|``` +70| +71|### Getting Schemas +72| +73|```java +74|Map schemas = adapter.getSchemas(); +75|Map dnaSchema = (Map) schemas.get("dna_schema"); +76|Map auditSchema = (Map) schemas.get("audit_schema"); +77|``` +78| +79|### Customizing Action and Version +80| +81|```java +82|ObjectNode result = adapter.wrap(data, "deploy", "P14-Lvmeng", "DEPLOY", "v2.0"); +83|``` +84| +85|## Kotlin Usage +86| +87|```kotlin +88|import cn.uid9622.longhun.LongHunAdapter +89| +90|val adapter = LongHunAdapter("9622", "HM-9622-001") +91|val result = adapter.wrap(mapOf("code" to "print('hello')"), "code", "P04-Luban") +92|val validation = adapter.validate(result) +93| +94|println(result["dna"]) // DNA traceability code +95|println(result["audit"]["behavior_pattern"]) // Behavior pattern +96|println(validation.summary) // Validation summary +97|``` +98| +99|## Building +100| +101|```bash +102|cd adapters/java +103|mvn clean package +104|``` +105| +106|## Running Tests +107| +108|```bash +109|cd adapters/java +110|mvn test +111|``` +112| +113|## API Reference +114| +115|### `LongHunAdapter` +116| +117|| Method | Returns | Description | +118||--------|---------|-------------| +119|| `LongHunAdapter(String uid, String device)` | — | Constructor with default locale | +120|| `LongHunAdapter(String uid, String device, String locale)` | — | Constructor with custom timezone | +121|| `wrap(Object data, String taskType, String persona)` | `ObjectNode` | Wrap payload with DNA + audit | +122|| `wrap(Object data, String taskType, String persona, String action, String version)` | `ObjectNode` | Wrap with custom action/version | +123|| `validate(ObjectNode wrapped)` | `ValidationResult` | Validate wrapped payload | +124|| `getSchemas()` | `Map` | Get JSON Schema definitions | +125| +126|### `ValidationResult` +127| +128|| Method | Returns | Description | +129||--------|---------|-------------| +130|| `isValid()` | `boolean` | Whether validation passed | +131|| `getErrors()` | `List` | Validation error messages | +132|| `getWarnings()` | `List` | Validation warning messages | +133|| `getSummary()` | `String` | Human-readable summary | +134| +135|## Project Structure +136| +137|``` +138|adapters/java/ +139|├── pom.xml +140|├── LICENSE +141|├── README.md +142|└── src/ +143| ├── main/java/cn/uid9622/longhun/ +144| │ ├── LongHunAdapter.java # Main adapter class +145| │ ├── DNAGenerator.java # DNA traceability code generation +146| │ ├── AuditWrapper.java # Seven-factor audit wrapping +147| │ ├── Validator.java # Payload validation +148| │ ├── ValidationResult.java # Immutable validation result +149| │ └── Schemas.java # JSON Schema definitions +150| └── test/java/cn/uid9622/longhun/ +151| ├── LongHunAdapterTest.java +152| ├── DNAGeneratorTest.java +153| ├── AuditWrapperTest.java +154| └── ValidatorTest.java +155|``` +156| +157|## License +158| +159|This project is licensed under [CC BY-NC-SA 4.0](LICENSE) — Attribution-NonCommercial-ShareAlike 4.0 International. +160| +161|## Cross-Validation +162| +163|The Java implementation is cross-validated against the Python reference implementation +164|at `lh_standard_adapter/`. All tests produce identical output structure and validation logic. +165| +166|## DNA +167| +168|``` +169|#LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-ADAPTER-JAVA-v1.0.0 +170|``` +171| +172|--- +173| +174|*Open the standard. Guard the engine.* \ No newline at end of file diff --git a/adapters/java/pom.xml b/adapters/java/pom.xml new file mode 100644 index 0000000..acc6c4a --- /dev/null +++ b/adapters/java/pom.xml @@ -0,0 +1,112 @@ +1| +2| +5| 4.0.0 +6| +7| cn.uid9622.longhun +8| lh-standard-adapter +9| 1.0.0 +10| jar +11| +12| LongHun Standard Adapter +13| Java/Kotlin implementation of the LongHun standard adapter – wrap JSON payloads with DNA traceability and seven-factor behavioral audit metadata. +14| https://github.com/UID9622/lh-standard-adapter +15| +16| +17| +18| CC BY-NC-SA 4.0 +19| https://creativecommons.org/licenses/by-nc-sa/4.0/ +20| +21| +22| +23| +24| +25| LongHun Core · UID9622 · 龍芯北辰 +26| core@uid9622.cn +27| +28| +29| +30| +31| 1.8 +32| 1.8 +33| UTF-8 +34| 2.15.3 +35| 5.10.0 +36| +37| +38| +39| +40| +41| com.fasterxml.jackson.core +42| jackson-databind +43| ${jackson.version} +44| +45| +46| com.fasterxml.jackson.core +47| jackson-core +48| ${jackson.version} +49| +50| +51| com.fasterxml.jackson.core +52| jackson-annotations +53| ${jackson.version} +54| +55| +56| +57| +58| org.junit.jupiter +59| junit-jupiter +60| ${junit.version} +61| test +62| +63| +64| +65| +66| com.google.code.findbugs +67| jsr305 +68| 3.0.2 +69| true +70| +71| +72| +73| +74| +75| +76| org.apache.maven.plugins +77| maven-compiler-plugin +78| 3.11.0 +79| +80| 1.8 +81| 1.8 +82| UTF-8 +83| +84| +85| +86| org.apache.maven.plugins +87| maven-surefire-plugin +88| 3.2.3 +89| +90| +91| **/*Test.java +92| +93| +94| +95| +96| org.apache.maven.plugins +97| maven-javadoc-plugin +98| 3.6.0 +99| +100| 1.8 +101| UTF-8 +102| none +103| +104| +105| +106| org.apache.maven.plugins +107| maven-source-plugin +108| 3.3.0 +109| +110| +111| +112| \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/AuditWrapper.java b/adapters/java/src/main/java/cn/uid9622/longhun/AuditWrapper.java new file mode 100644 index 0000000..c12a2c4 --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/AuditWrapper.java @@ -0,0 +1,268 @@ +1|package cn.uid9622.longhun; +2| +3|import javax.annotation.Nonnull; +4|import java.nio.charset.StandardCharsets; +5|import java.security.MessageDigest; +6|import java.security.NoSuchAlgorithmException; +7|import java.time.ZoneId; +8|import java.time.ZonedDateTime; +9|import java.time.format.DateTimeFormatter; +10|import java.util.*; +11| +12|/** +13| * Wraps payloads with seven-factor behavioral audit metadata. +14| * +15| *

Core scoring algorithms (weights, neural network logic) are +16| * protected engine components and NOT included in this open shell. +17| * +18| *

DNA: #LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷝Li-AUDIT-WRAPPER-v1.0.0 +19| * +20| * @since 1.0.0 +21| */ +22|public final class AuditWrapper { +23| +24| // --- Seven-Factor Value Sets --- +25| private static final Set P_VALUES = setOf("HasPromise", "NoPromise"); +26| private static final Set F_VALUES = setOf("Fulfilled", "Unfulfilled", "Partial"); +27| private static final Set E_VALUES = setOf("Willing", "Perfunctory", "Resentful", "Numb"); +28| private static final Set A_VALUES = setOf("Self", "Partner", "Family", "Outsider", "Public"); +29| private static final Set X_VALUES = setOf("OverExplain", "Silent", "Genuine", "Indifferent"); +30| private static final Set Y_VALUES = setOf("Changed", "Resisted", "Indifferent", "NoResponse"); +31| +32| // --- Behavior Pattern Classification --- +33| private static final Map PATTERNS = new LinkedHashMap<>(); +34| +35| static { +36| PATTERNS.put("MODE-DefensiveDefaulter", "Promises fail + over-explains to deflect"); +37| PATTERNS.put("MODE-ExternalTrustSpender", "Keeps promises to outsiders at inner-circle expense"); +38| PATTERNS.put("MODE-InternalDestroyer", "Breaks promises with indifference, no correction"); +39| PATTERNS.put("MODE-Fluctuating", "High volatility in commitment-to-fulfillment ratio"); +40| PATTERNS.put("MODE-StableDisciplined", "Consistent, reliable execution"); +41| } +42| +43| // --- Factor → Label Mapping (bilingual) --- +44| private static final Map> LABEL_MAP = new LinkedHashMap<>(); +45| +46| static { +47| LABEL_MAP.put("P", mapOf("HasPromise", "7F-P-有承诺", "NoPromise", "7F-P-无承诺")); +48| LABEL_MAP.put("F", mapOf("Fulfilled", "7F-F-已兑现", "Unfulfilled", "7F-F-未兑现", "Partial", "7F-F-部分兑现")); +49| LABEL_MAP.put("E", mapOf("Willing", "7F-E-心甘情愿", "Perfunctory", "7F-E-敷衍", "Resentful", "7F-E-怨恨", "Numb", "7F-E-麻木")); +50| LABEL_MAP.put("A", mapOf("Self", "7F-A-自己", "Partner", "7F-A-伴侣", "Family", "7F-A-家庭", "Outsider", "7F-A-外人", "Public", "7F-A-公众")); +51| LABEL_MAP.put("X", mapOf("OverExplain", "7F-X-过度解释", "Silent", "7F-X-沉默", "Genuine", "7F-X-真诚", "Indifferent", "7F-X-冷漠")); +52| LABEL_MAP.put("Y", mapOf("Changed", "7F-Y-改正", "Resisted", "7F-Y-抗拒", "Indifferent", "7F-Y-无视", "NoResponse", "7F-Y-无响应")); +53| } +54| +55| private final String uid; +56| +57| /** +58| * Creates a new {@code AuditWrapper}. +59| * +60| * @param uid user identifier (e.g., "9622") +61| */ +62| public AuditWrapper(String uid) { +63| this.uid = Objects.requireNonNull(uid, "uid must not be null"); +64| } +65| +66| /** +67| * Generates the audit wrapper with seven-factor signature. +68| * +69| * @param payload raw data to wrap (must be JSON-serializable) +70| * @param taskType task category (code, deploy, audit, default, etc.) +71| * @param persona persona identifier (e.g., "P04", "P04-Luban") +72| * @return map of audit metadata +73| */ +74| @Nonnull +75| public Map wrap(@Nonnull Object payload, +76| @Nonnull String taskType, +77| @Nonnull String persona) { +78| Objects.requireNonNull(payload, "payload must not be null"); +79| Objects.requireNonNull(taskType, "taskType must not be null"); +80| Objects.requireNonNull(persona, "persona must not be null"); +81| +82| ZonedDateTime now = ZonedDateTime.now(ZoneId.of("Asia/Shanghai")); +83| +84| // Default signature (StableDisciplined baseline) +85| Map signature = new LinkedHashMap<>(); +86| signature.put("P", "HasPromise"); +87| signature.put("F", "Fulfilled"); +88| signature.put("T", 0.0); +89| signature.put("E", "Willing"); +90| signature.put("C", 0); +91| signature.put("R", 0); +92| signature.put("A", "Self"); +93| signature.put("X", "Genuine"); +94| signature.put("Y", "NoResponse"); +95| signature.put("Z", 1.0); +96| +97| String pattern = classify(signature); +98| List labels = makeLabels(signature, pattern); +99| String color = determineColor(pattern, (Integer) signature.get("R")); +100| +101| // Payload hash (not for crypto, for integrity check) +102| String payloadJson = payload.toString(); // simplified; Jackson serialization happens upstream +103| String payloadHash = sha256Hex(payloadJson).substring(0, 16); +104| +105| Map result = new LinkedHashMap<>(); +106| result.put("audit_version", "v1.0"); +107| result.put("uid", "UID" + uid); +108| result.put("persona", persona); +109| result.put("task_type", taskType); +110| result.put("behavior_signature", signature); +111| result.put("behavior_pattern", pattern); +112| result.put("behavior_labels", labels); +113| result.put("color", color); +114| result.put("timestamp", now.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)); +115| result.put("payload_hash", payloadHash); +116| +117| return result; +118| } +119| +120| /** +121| * Classifies a seven-factor signature into a behavior pattern. +122| * +123| * @param sig the behavior signature map +124| * @return behavior pattern string (e.g., "MODE-StableDisciplined") +125| */ +126| @Nonnull +127| String classify(@Nonnull Map sig) { +128| String fVal = (String) sig.getOrDefault("F", ""); +129| String xVal = (String) sig.getOrDefault("X", ""); +130| String aVal = (String) sig.getOrDefault("A", ""); +131| String yVal = (String) sig.getOrDefault("Y", ""); +132| Number zVal = (Number) sig.getOrDefault("Z", 1.0); +133| +134| if ("Unfulfilled".equals(fVal) && "OverExplain".equals(xVal)) { +135| return "MODE-DefensiveDefaulter"; +136| } +137| if ("Fulfilled".equals(fVal) && "Outsider".equals(aVal)) { +138| return "MODE-ExternalTrustSpender"; +139| } +140| if ("Unfulfilled".equals(fVal) && "Indifferent".equals(yVal)) { +141| return "MODE-InternalDestroyer"; +142| } +143| if (zVal.doubleValue() > 2.0) { +144| return "MODE-Fluctuating"; +145| } +146| return "MODE-StableDisciplined"; +147| } +148| +149| /** +150| * Generates bilingual behavior labels from a signature. +151| * +152| * @param sig the behavior signature map +153| * @param pattern the classified behavior pattern +154| * @return list of bilingual label strings +155| */ +156| @Nonnull +157| List makeLabels(@Nonnull Map sig, @Nonnull String pattern) { +158| List labels = new ArrayList<>(); +159| for (String factor : Arrays.asList("P", "F", "E", "A", "X", "Y")) { +160| String val = (String) sig.get(factor); +161| if (val != null) { +162| Map factorLabels = LABEL_MAP.get(factor); +163| if (factorLabels != null && factorLabels.containsKey(val)) { +164| labels.add(factorLabels.get(val)); +165| } +166| } +167| } +168| labels.add(pattern); +169| return labels; +170| } +171| +172| /** +173| * Determines the three-color audit tag. +174| * +175| * @param pattern the behavior pattern +176| * @param repeat repeat count (R) +177| * @return color emoji string: 🟢, 🟡, or 🔴 +178| */ +179| @Nonnull +180| String determineColor(@Nonnull String pattern, int repeat) { +181| if ("MODE-InternalDestroyer".equals(pattern)) { +182| return "\uD83D\uDD34"; // 🔴 +183| } +184| if ("MODE-Fluctuating".equals(pattern) && repeat > 3) { +185| return "\uD83D\uDFE1"; // 🟡 +186| } +187| if ("MODE-DefensiveDefaulter".equals(pattern) && repeat > 2) { +188| return "\uD83D\uDFE1"; // 🟡 +189| } +190| return "\uD83D\uDFE2"; // 🟢 +191| } +192| +193| @Nonnull +194| String getUid() { +195| return uid; +196| } +197| +198| @Nonnull +199| static Set getPValues() { +200| return P_VALUES; +201| } +202| +203| @Nonnull +204| static Set getFValues() { +205| return F_VALUES; +206| } +207| +208| @Nonnull +209| static Set getEValues() { +210| return E_VALUES; +211| } +212| +213| @Nonnull +214| static Set getAValues() { +215| return A_VALUES; +216| } +217| +218| @Nonnull +219| static Set getXValues() { +220| return X_VALUES; +221| } +222| +223| @Nonnull +224| static Set getYValues() { +225| return Y_VALUES; +226| } +227| +228| @Nonnull +229| static Map getPatterns() { +230| return PATTERNS; +231| } +232| +233| @Nonnull +234| static Map> getLabelMap() { +235| return LABEL_MAP; +236| } +237| +238| // --- Private helpers --- +239| +240| private static Set setOf(String... values) { +241| Set set = new LinkedHashSet<>(); +242| Collections.addAll(set, values); +243| return Collections.unmodifiableSet(set); +244| } +245| +246| private static Map mapOf(String... entries) { +247| Map map = new LinkedHashMap<>(); +248| for (int i = 0; i < entries.length; i += 2) { +249| map.put(entries[i], entries[i + 1]); +250| } +251| return map; +252| } +253| +254| @Nonnull +255| private static String sha256Hex(@Nonnull String input) { +256| try { +257| MessageDigest md = MessageDigest.getInstance("SHA-256"); +258| byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8)); +259| StringBuilder sb = new StringBuilder(64); +260| for (byte b : digest) { +261| sb.append(String.format("%02x", b & 0xff)); +262| } +263| return sb.toString(); +264| } catch (NoSuchAlgorithmException e) { +265| throw new RuntimeException("SHA-256 not available", e); +266| } +267| } +268|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/DNAGenerator.java b/adapters/java/src/main/java/cn/uid9622/longhun/DNAGenerator.java new file mode 100644 index 0000000..f097547 --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/DNAGenerator.java @@ -0,0 +1,259 @@ +1|package cn.uid9622.longhun; +2| +3|import javax.annotation.Nonnull; +4|import javax.annotation.Nullable; +5|import java.nio.charset.StandardCharsets; +6|import java.security.MessageDigest; +7|import java.security.NoSuchAlgorithmException; +8|import java.time.LocalDateTime; +9|import java.time.ZoneId; +10|import java.time.ZonedDateTime; +11|import java.util.*; +12| +13|/** +14| * Generates v∞ format DNA traceability codes for the LongHun standard. +15| * +16| *

Format: {@code #LongHun⚡️{YearStem}·{MonthStem}·{DayStem}·{ShiChen}·{Hexagram}-{Body}-{Hash8}} +17| * +18| *

DNA: #LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-DNA-GENERATOR-v1.0.0 +19| * +20| * @since 1.0.0 +21| */ +22|public final class DNAGenerator { +23| +24| // --- Heavenly Stems (天干) --- +25| private static final String[] TIAN_GAN = { +26| "Jia", "Yi", "Bing", "Ding", "Wu", "Ji", "Geng", "Xin", "Ren", "Gui" +27| }; +28| +29| // --- Earthly Branches (地支) --- +30| private static final String[] DI_ZHI = { +31| "Zi", "Chou", "Yin", "Mao", "Chen", "Si", +32| "Wu", "Wei", "Shen", "You", "Xu", "Hai" +33| }; +34| +35| // --- ShiChen (时辰) --- +36| private static final String[] SHI_CHEN = { +37| "ZiShi", "ChouShi", "YinShi", "MaoShi", "ChenShi", "SiShi", +38| "WuShi", "WeiShi", "ShenShi", "YouShi", "XuShi", "HaiShi" +39| }; +40| +41| // --- I Ching Hexagrams --- +42| private static final List> HEXAGRAMS = buildHexagrams(); +43| +44| // --- Task-to-hexagram domain mapping --- +45| private static final Map TASK_HEXAGRAM_MAP = new LinkedHashMap<>(); +46| +47| static { +48| TASK_HEXAGRAM_MAP.put("default", "governance"); +49| TASK_HEXAGRAM_MAP.put("code", "engine"); +50| TASK_HEXAGRAM_MAP.put("deploy", "deploy"); +51| TASK_HEXAGRAM_MAP.put("audit", "audit"); +52| TASK_HEXAGRAM_MAP.put("security", "security"); +53| TASK_HEXAGRAM_MAP.put("archive", "archive"); +54| TASK_HEXAGRAM_MAP.put("init", "init"); +55| TASK_HEXAGRAM_MAP.put("learn", "learn"); +56| TASK_HEXAGRAM_MAP.put("legal", "legal"); +57| TASK_HEXAGRAM_MAP.put("privacy", "privacy"); +58| TASK_HEXAGRAM_MAP.put("trust", "trust"); +59| TASK_HEXAGRAM_MAP.put("complete", "complete"); +60| TASK_HEXAGRAM_MAP.put("progress", "progress"); +61| } +62| +63| private static final int CYCLE_YEAR = 1984; // JiaZi year reference +64| // Month stems offset per decade +65| private static final int[] CYCLE_MONTH = {2, 4, 6, 8, 10, 0, 2, 4, 6, 8, 10, 0}; +66| +67| private final String uid; +68| private final String device; +69| private final String locale; +70| +71| /** +72| * Creates a new {@code DNAGenerator}. +73| * +74| * @param uid user identifier (e.g., "9622") +75| * @param device device identifier (e.g., "HM-9622-001") +76| * @param locale timezone locale (e.g., "Asia/Shanghai") +77| */ +78| public DNAGenerator(String uid, String device, String locale) { +79| this.uid = Objects.requireNonNull(uid, "uid must not be null"); +80| this.device = Objects.requireNonNull(device, "device must not be null"); +81| this.locale = Objects.requireNonNull(locale, "locale must not be null"); +82| } +83| +84| /** +85| * Generates a full DNA traceability string. +86| * +87| * @param taskType task category (code, deploy, audit, default, etc.) +88| * @param action action descriptor (WRAP, GENERATE, DEPLOY, AUDIT, etc.) +89| * @param version optional version override (e.g., "v1.0"), defaults to "V1.0" +90| * @return DNA traceability string in v∞ format +91| */ +92| @Nonnull +93| public String generate(@Nonnull String taskType, +94| @Nonnull String action, +95| @Nullable String version) { +96| Objects.requireNonNull(taskType, "taskType must not be null"); +97| Objects.requireNonNull(action, "action must not be null"); +98| +99| ZonedDateTime now = ZonedDateTime.now(ZoneId.of(locale)); +100| Map stem = computeStemBranch(now); +101| Map hexagram = selectHexagram(taskType); +102| String ver = (version != null) ? version : "V1.0"; +103| +104| String body = "ADAPTER-" + taskType.toUpperCase(Locale.ROOT) +105| + "-" + action.toUpperCase(Locale.ROOT) +106| + "-" + ver; +107| +108| String raw = stem.get("year") + stem.get("month") + stem.get("day") + stem.get("shichen") +109| + hexagram.get("symbol") + hexagram.get("enName") +110| + body +111| + device +112| + now.toLocalDateTime().toString(); +113| +114| String hash8 = sha256Hex(raw).substring(0, 8); +115| +116| return "#LongHun⚡️" + stem.get("year") + "·" + stem.get("month") + "·" + stem.get("day") + "·" + stem.get("shichen") +117| + "·" + hexagram.get("symbol") + hexagram.get("enName") +118| + "-" + body + "-" + hash8; +119| } +120| +121| /** +122| * Computes the Heavenly Stem and Earthly Branch values for a given datetime. +123| * +124| * @param dt the datetime to compute from +125| * @return map with keys: year, month, day, shichen +126| */ +127| @Nonnull +128| Map computeStemBranch(@Nonnull ZonedDateTime dt) { +129| Objects.requireNonNull(dt, "dt must not be null"); +130| +131| int year = dt.getYear(); +132| int month = dt.getMonthValue(); +133| int day = dt.getDayOfYear(); +134| +135| int yearStemIdx = (year - CYCLE_YEAR) % 10; +136| if (yearStemIdx < 0) yearStemIdx += 10; +137| int yearBranchIdx = (year - CYCLE_YEAR) % 12; +138| if (yearBranchIdx < 0) yearBranchIdx += 12; +139| +140| int decadeIdx = (year - CYCLE_YEAR) % 10; +141| if (decadeIdx < 0) decadeIdx += 10; +142| int monthStemRaw = CYCLE_MONTH[decadeIdx]; +143| int monthStemIdx = (monthStemRaw + (month - 1)) % 10; +144| if (monthStemIdx < 0) monthStemIdx += 10; +145| int monthBranchIdx = (month + 1) % 12; +146| +147| int dayOffset = (year - 1900) + (year - 1900) / 4 + day; +148| int dayStemIdx = dayOffset % 10; +149| if (dayStemIdx < 0) dayStemIdx += 10; +150| int dayBranchIdx = dayOffset % 12; +151| if (dayBranchIdx < 0) dayBranchIdx += 12; +152| +153| int shichenIdx = dt.getHour() / 2; +154| if (shichenIdx >= 12) shichenIdx = 11; +155| +156| Map result = new LinkedHashMap<>(); +157| result.put("year", TIAN_GAN[yearStemIdx] + DI_ZHI[yearBranchIdx]); +158| result.put("month", TIAN_GAN[monthStemIdx] + DI_ZHI[monthBranchIdx]); +159| result.put("day", TIAN_GAN[dayStemIdx] + DI_ZHI[dayBranchIdx]); +160| result.put("shichen", SHI_CHEN[shichenIdx]); +161| return result; +162| } +163| +164| /** +165| * Selects an I Ching hexagram based on task type. +166| * +167| * @param taskType the task category +168| * @return map with keys: symbol, enName, cnName, domain +169| */ +170| @Nonnull +171| Map selectHexagram(@Nonnull String taskType) { +172| String domain = TASK_HEXAGRAM_MAP.getOrDefault(taskType, "governance"); +173| for (Map h : HEXAGRAMS) { +174| if (domain.equals(h.get("domain"))) { +175| return h; +176| } +177| } +178| return HEXAGRAMS.get(0); // Default: Qian (governance) +179| } +180| +181| /** +182| * Returns the list of all I Ching hexagrams with their metadata. +183| * +184| * @return unmodifiable list of hexagram maps +185| */ +186| @Nonnull +187| static List> getHexagrams() { +188| return HEXAGRAMS; +189| } +190| +191| /** +192| * Returns the task-to-hexagram domain mapping. +193| * +194| * @return unmodifiable map of task type to hexagram domain +195| */ +196| @Nonnull +197| static Map getTaskHexagramMap() { +198| return Collections.unmodifiableMap(TASK_HEXAGRAM_MAP); +199| } +200| +201| @Nonnull +202| String getUid() { +203| return uid; +204| } +205| +206| @Nonnull +207| String getDevice() { +208| return device; +209| } +210| +211| @Nonnull +212| String getLocale() { +213| return locale; +214| } +215| +216| // --- Private helpers --- +217| +218| private static List> buildHexagrams() { +219| List> list = new ArrayList<>(); +220| list.add(mapOf("symbol", "䷀", "enName", "Qian", "cnName", "乾", "domain", "governance")); +221| list.add(mapOf("symbol", "䷁", "enName", "Kun", "cnName", "坤", "domain", "archive")); +222| list.add(mapOf("symbol", "䷂", "enName", "Zhun", "cnName", "屯", "domain", "init")); +223| list.add(mapOf("symbol", "䷃", "enName", "Meng", "cnName", "蒙", "domain", "learn")); +224| list.add(mapOf("symbol", "䷄", "enName", "Xu", "cnName", "需", "domain", "async")); +225| list.add(mapOf("symbol", "䷅", "enName", "Song", "cnName", "讼", "domain", "legal")); +226| list.add(mapOf("symbol", "䷜", "enName", "Kan", "cnName", "坎", "domain", "engine")); +227| list.add(mapOf("symbol", "䷝", "enName", "Li", "cnName", "离", "domain", "audit")); +228| list.add(mapOf("symbol", "䷲", "enName", "Zhen", "cnName", "震", "domain", "security")); +229| list.add(mapOf("symbol", "䷳", "enName", "Gen", "cnName", "艮", "domain", "privacy")); +230| list.add(mapOf("symbol", "䷸", "enName", "Xun", "cnName", "巽", "domain", "deploy")); +231| list.add(mapOf("symbol", "䷹", "enName", "Dui", "cnName", "兑", "domain", "trust")); +232| list.add(mapOf("symbol", "䷾", "enName", "JiJi", "cnName", "既济", "domain", "complete")); +233| list.add(mapOf("symbol", "䷿", "enName", "WeiJi", "cnName", "未济", "domain", "progress")); +234| return Collections.unmodifiableList(list); +235| } +236| +237| private static Map mapOf(String... entries) { +238| Map map = new LinkedHashMap<>(); +239| for (int i = 0; i < entries.length; i += 2) { +240| map.put(entries[i], entries[i + 1]); +241| } +242| return map; +243| } +244| +245| @Nonnull +246| private static String sha256Hex(@Nonnull String input) { +247| try { +248| MessageDigest md = MessageDigest.getInstance("SHA-256"); +249| byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8)); +250| StringBuilder sb = new StringBuilder(64); +251| for (byte b : digest) { +252| sb.append(String.format("%02x", b & 0xff)); +253| } +254| return sb.toString(); +255| } catch (NoSuchAlgorithmException e) { +256| throw new RuntimeException("SHA-256 not available", e); +257| } +258| } +259|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/LongHunAdapter.java b/adapters/java/src/main/java/cn/uid9622/longhun/LongHunAdapter.java new file mode 100644 index 0000000..232e09d --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/LongHunAdapter.java @@ -0,0 +1,280 @@ +1|package cn.uid9622.longhun; +2| +3|import com.fasterxml.jackson.databind.JsonNode; +4|import com.fasterxml.jackson.databind.ObjectMapper; +5|import com.fasterxml.jackson.databind.node.ObjectNode; +6| +7|import javax.annotation.Nonnull; +8|import javax.annotation.Nullable; +9|import java.time.ZonedDateTime; +10|import java.time.ZoneId; +11|import java.time.format.DateTimeFormatter; +12|import java.util.*; +13| +14|/** +15| * LongHun Standard Adapter — wrap JSON payloads with DNA traceability +16| * and seven-factor behavioral audit metadata. +17| * +18| *

DNA: #LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-ADAPTER-v1.0.0 +19| *
Author: LongHun Core · UID9622 · 龍芯北辰 +20| *
License: CC BY-NC-SA 4.0 +21| * +22| *

Usage (Java): +23| * 

{@code
+24| * LongHunAdapter adapter = new LongHunAdapter("9622", "HM-9622-001");
+25| * ObjectNode result = adapter.wrap(data, "code", "P04-Luban");
+26| * ValidationResult validation = adapter.validate(result);
+27| * }
+28| * +29| *

Usage (Kotlin): +30| * 

{@code
+31| * val adapter = LongHunAdapter("9622", "HM-9622-001")
+32| * val result = adapter.wrap(data, "code", "P04-Luban")
+33| * val validation = adapter.validate(result)
+34| * }
+35| * +36| * @since 1.0.0 +37| */ +38|public final class LongHunAdapter { +39| +40| /** Current adapter version. */ +41| public static final String VERSION = "1.0.0"; +42| +43| private static final String AUTHOR = "LongHun Core · UID9622 · 龍芯北辰"; +44| private static final String LICENSE = "CC BY-NC-SA 4.0"; +45| private static final String DNA = "#LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-ADAPTER-v1.0.0-4f7a3b1c"; +46| +47| private static final ObjectMapper MAPPER = new ObjectMapper(); +48| +49| private final String uid; +50| private final String device; +51| private final String locale; +52| private final DNAGenerator dnaGen; +53| private final AuditWrapper audit; +54| private final Validator validator; +55| +56| /** +57| * Creates a new {@code LongHunAdapter} with default locale "Asia/Shanghai". +58| * +59| * @param uid user identifier (e.g., "9622") +60| * @param device device identifier (e.g., "HM-9622-001") +61| * @throws NullPointerException if uid or device is null +62| */ +63| public LongHunAdapter(@Nonnull String uid, @Nonnull String device) { +64| this(uid, device, "Asia/Shanghai"); +65| } +66| +67| /** +68| * Creates a new {@code LongHunAdapter} with a custom locale. +69| * +70| * @param uid user identifier (e.g., "9622") +71| * @param device device identifier (e.g., "HM-9622-001") +72| * @param locale timezone locale (e.g., "Asia/Shanghai") +73| * @throws NullPointerException if any argument is null +74| */ +75| public LongHunAdapter(@Nonnull String uid, @Nonnull String device, @Nonnull String locale) { +76| this.uid = Objects.requireNonNull(uid, "uid must not be null"); +77| this.device = Objects.requireNonNull(device, "device must not be null"); +78| this.locale = Objects.requireNonNull(locale, "locale must not be null"); +79| this.dnaGen = new DNAGenerator(uid, device, locale); +80| this.audit = new AuditWrapper(uid); +81| this.validator = new Validator(); +82| } +83| +84| /** +85| * Wraps a payload with DNA traceability and audit metadata. +86| * +87| *

This is the primary entry point for the adapter. The returned +88| * {@link ObjectNode} contains four keys: {@code dna}, {@code audit}, +89| * {@code payload}, and {@code meta}. +90| * +91| * @param data raw payload (any JSON-serializable object) +92| * @param taskType task category (code, deploy, audit, default, etc.) +93| * @param persona persona identifier (e.g., "P04", "P04-Luban") +94| * @return {@link ObjectNode} with keys: dna, audit, payload, meta +95| * @throws NullPointerException if any argument is null +96| */ +97| @Nonnull +98| public ObjectNode wrap(@Nonnull Object data, +99| @Nonnull String taskType, +100| @Nonnull String persona) { +101| return wrap(data, taskType, persona, "WRAP", null); +102| } +103| +104| /** +105| * Wraps a payload with full control over action and version. +106| * +107| * @param data raw payload (any JSON-serializable object) +108| * @param taskType task category +109| * @param persona persona identifier +110| * @param action action descriptor (WRAP, GENERATE, DEPLOY, AUDIT) +111| * @param version optional version override (e.g., "v1.0") +112| * @return {@link ObjectNode} with keys: dna, audit, payload, meta +113| * @throws NullPointerException if data, taskType, persona, or action is null +114| */ +115| @Nonnull +116| public ObjectNode wrap(@Nonnull Object data, +117| @Nonnull String taskType, +118| @Nonnull String persona, +119| @Nonnull String action, +120| @Nullable String version) { +121| Objects.requireNonNull(data, "data must not be null"); +122| Objects.requireNonNull(taskType, "taskType must not be null"); +123| Objects.requireNonNull(persona, "persona must not be null"); +124| Objects.requireNonNull(action, "action must not be null"); +125| +126| // Generate DNA +127| String dna = dnaGen.generate(taskType, action, version); +128| +129| // Generate audit wrapper +130| Map auditResult = audit.wrap(data, taskType, persona); +131| +132| // Build meta +133| ZonedDateTime now = ZonedDateTime.now(ZoneId.of(locale)); +134| Map meta = new LinkedHashMap<>(); +135| meta.put("adapter_version", VERSION); +136| meta.put("uid", uid); +137| meta.put("device", device); +138| meta.put("task_type", taskType); +139| meta.put("persona", persona); +140| meta.put("generated_at", now.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)); +141| meta.put("format", "longhun-v\u221E"); +142| +143| // Build result +144| ObjectNode result = MAPPER.createObjectNode(); +145| result.put("dna", dna); +146| result.set("audit", MAPPER.valueToTree(auditResult)); +147| result.set("payload", MAPPER.valueToTree(data)); +148| result.set("meta", MAPPER.valueToTree(meta)); +149| +150| return result; +151| } +152| +153| /** +154| * Validates a wrapped payload for LongHun standard compliance. +155| * +156| * @param wrapped the {@link ObjectNode} produced by {@link #wrap} +157| * @return {@link ValidationResult} with valid flag, errors, warnings, and summary +158| * @throws NullPointerException if wrapped is null +159| */ +160| @Nonnull +161| public ValidationResult validate(@Nonnull ObjectNode wrapped) { +162| Objects.requireNonNull(wrapped, "wrapped must not be null"); +163| return validator.validate(wrapped); +164| } +165| +166| /** +167| * Returns JSON Schemas for DNA and Audit formats. +168| * +169| * @return map with keys: "dna_schema", "audit_schema" +170| */ +171| @Nonnull +172| public Map getSchemas() { +173| Map schemas = new LinkedHashMap<>(); +174| schemas.put("dna_schema", Schemas.getDnaSchema()); +175| schemas.put("audit_schema", Schemas.getAuditSchema()); +176| return schemas; +177| } +178| +179| // --- Accessors --- +180| +181| /** +182| * Returns the user identifier. +183| * +184| * @return uid string +185| */ +186| @Nonnull +187| public String getUid() { +188| return uid; +189| } +190| +191| /** +192| * Returns the device identifier. +193| * +194| * @return device string +195| */ +196| @Nonnull +197| public String getDevice() { +198| return device; +199| } +200| +201| /** +202| * Returns the timezone locale. +203| * +204| * @return locale string (e.g., "Asia/Shanghai") +205| */ +206| @Nonnull +207| public String getLocale() { +208| return locale; +209| } +210| +211| /** +212| * Returns the adapter version. +213| * +214| * @return "1.0.0" +215| */ +216| @Nonnull +217| public static String getVersion() { +218| return VERSION; +219| } +220| +221| /** +222| * Returns the adapter author string. +223| * +224| * @return author string +225| */ +226| @Nonnull +227| public static String getAuthor() { +228| return AUTHOR; +229| } +230| +231| /** +232| * Returns the adapter license string. +233| * +234| * @return "CC BY-NC-SA 4.0" +235| */ +236| @Nonnull +237| public static String getLicense() { +238| return LICENSE; +239| } +240| +241| /** +242| * Returns the adapter DNA signature. +243| * +244| * @return DNA string +245| */ +246| @Nonnull +247| public static String getDna() { +248| return DNA; +249| } +250| +251| /** +252| * Returns the internal {@link DNAGenerator} (for advanced use). +253| * +254| * @return DNAGenerator instance +255| */ +256| @Nonnull +257| public DNAGenerator getDnaGenerator() { +258| return dnaGen; +259| } +260| +261| /** +262| * Returns the internal {@link AuditWrapper} (for advanced use). +263| * +264| * @return AuditWrapper instance +265| */ +266| @Nonnull +267| public AuditWrapper getAuditWrapper() { +268| return audit; +269| } +270| +271| /** +272| * Returns the internal {@link Validator} (for advanced use). +273| * +274| * @return Validator instance +275| */ +276| @Nonnull +277| public Validator getValidator() { +278| return validator; +279| } +280|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/Schemas.java b/adapters/java/src/main/java/cn/uid9622/longhun/Schemas.java new file mode 100644 index 0000000..84e6f12 --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/Schemas.java @@ -0,0 +1,234 @@ +1|package cn.uid9622.longhun; +2| +3|import javax.annotation.Nonnull; +4|import java.util.LinkedHashMap; +5|import java.util.Map; +6| +7|/** +8| * JSON Schema definitions for LongHun DNA and Audit formats. +9| * +10| *

These schemas match the Python reference implementation in +11| * {@code lh_standard_adapter/schemas/__init__.py}. +12| * +13| * @since 1.0.0 +14| */ +15|public final class Schemas { +16| +17| private Schemas() { +18| // utility class +19| } +20| +21| /** +22| * Returns the JSON Schema for the DNA traceability code. +23| * +24| * @return map representing the DNA JSON Schema +25| */ +26| @Nonnull +27| @SuppressWarnings("unchecked") +28| public static Map getDnaSchema() { +29| return DNA_SCHEMA; +30| } +31| +32| /** +33| * Returns the JSON Schema for the audit record. +34| * +35| * @return map representing the Audit JSON Schema +36| */ +37| @Nonnull +38| @SuppressWarnings("unchecked") +39| public static Map getAuditSchema() { +40| return AUDIT_SCHEMA; +41| } +42| +43| // --- DNA Schema --- +44| +45| @SuppressWarnings("unchecked") +46| private static final Map DNA_SCHEMA = buildDnaSchema(); +47| +48| private static Map buildDnaSchema() { +49| Map schema = new LinkedHashMap<>(); +50| schema.put("$schema", "https://json-schema.org/draft/2020-12/schema"); +51| schema.put("$id", "https://uid9622.cn/schemas/dna-v1.0.json"); +52| schema.put("title", "LongHun DNA Traceability Code"); +53| schema.put("type", "object"); +54| +55| // required +56| schema.put("required", listOf("dna", "format", "uid", "timestamp")); +57| +58| // properties +59| Map properties = new LinkedHashMap<>(); +60| +61| Map dnaProp = new LinkedHashMap<>(); +62| dnaProp.put("type", "string"); +63| dnaProp.put("description", "Full v∞ DNA traceability code"); +64| dnaProp.put("pattern", "^#LongHun⚡️[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[䷀-䷿][A-Za-z]+-.+-[a-f0-9]{8}$"); +65| properties.put("dna", dnaProp); +66| +67| Map formatProp = new LinkedHashMap<>(); +68| formatProp.put("type", "string"); +69| formatProp.put("enum", listOf("v1.0", "v2.0", "v∞", "compact")); +70| properties.put("format", formatProp); +71| +72| Map uidProp = new LinkedHashMap<>(); +73| uidProp.put("type", "string"); +74| uidProp.put("pattern", "^UID\\d+$"); +75| properties.put("uid", uidProp); +76| +77| Map deviceProp = new LinkedHashMap<>(); +78| deviceProp.put("type", "string"); +79| properties.put("device", deviceProp); +80| +81| Map tsProp = new LinkedHashMap<>(); +82| tsProp.put("type", "string"); +83| tsProp.put("format", "date-time"); +84| properties.put("timestamp", tsProp); +85| +86| schema.put("properties", properties); +87| return schema; +88| } +89| +90| // --- Audit Schema --- +91| +92| @SuppressWarnings("unchecked") +93| private static final Map AUDIT_SCHEMA = buildAuditSchema(); +94| +95| private static Map buildAuditSchema() { +96| Map schema = new LinkedHashMap<>(); +97| schema.put("$schema", "https://json-schema.org/draft/2020-12/schema"); +98| schema.put("$id", "https://uid9622.cn/schemas/audit-v1.0.json"); +99| schema.put("title", "LongHun Audit Record"); +100| schema.put("type", "object"); +101| +102| // required +103| schema.put("required", listOf("dna", "audit", "payload", "meta")); +104| +105| // properties +106| Map properties = new LinkedHashMap<>(); +107| +108| // dna +109| Map dnaProp = new LinkedHashMap<>(); +110| dnaProp.put("type", "string"); +111| properties.put("dna", dnaProp); +112| +113| // audit +114| Map auditProp = buildAuditObjectSchema(); +115| properties.put("audit", auditProp); +116| +117| // payload (any) +118| properties.put("payload", new LinkedHashMap<>()); +119| +120| // meta +121| Map metaProp = buildMetaSchema(); +122| properties.put("meta", metaProp); +123| +124| schema.put("properties", properties); +125| return schema; +126| } +127| +128| @SuppressWarnings("unchecked") +129| private static Map buildAuditObjectSchema() { +130| Map audit = new LinkedHashMap<>(); +131| audit.put("type", "object"); +132| audit.put("required", listOf( +133| "audit_version", "uid", "behavior_signature", +134| "behavior_pattern", "behavior_labels", "color" +135| )); +136| +137| Map auditProps = new LinkedHashMap<>(); +138| +139| auditProps.put("audit_version", mapOf("type", "string")); +140| auditProps.put("uid", mapOf("type", "string")); +141| auditProps.put("persona", mapOf("type", "string")); +142| auditProps.put("task_type", mapOf("type", "string")); +143| +144| // behavior_signature +145| Map sig = new LinkedHashMap<>(); +146| sig.put("type", "object"); +147| sig.put("required", listOf("P", "F", "T", "E", "C", "R", "A", "X", "Y", "Z")); +148| +149| Map sigProps = new LinkedHashMap<>(); +150| sigProps.put("P", mapOf("enum", listOf("HasPromise", "NoPromise"))); +151| sigProps.put("F", mapOf("enum", listOf("Fulfilled", "Unfulfilled", "Partial"))); +152| sigProps.put("T", mapOf("type", "number")); +153| sigProps.put("E", mapOf("enum", listOf("Willing", "Perfunctory", "Resentful", "Numb"))); +154| sigProps.put("C", mapOf("type", "number")); +155| sigProps.put("R", mapOf("type", "integer", "minimum", 0)); +156| sigProps.put("A", mapOf("enum", listOf("Self", "Partner", "Family", "Outsider", "Public"))); +157| sigProps.put("X", mapOf("enum", listOf("OverExplain", "Silent", "Genuine", "Indifferent"))); +158| sigProps.put("Y", mapOf("enum", listOf("Changed", "Resisted", "Indifferent", "NoResponse"))); +159| sigProps.put("Z", mapOf("type", "number")); +160| sig.put("properties", sigProps); +161| +162| auditProps.put("behavior_signature", sig); +163| +164| // behavior_pattern +165| auditProps.put("behavior_pattern", mapOf("enum", listOf( +166| "MODE-DefensiveDefaulter", "MODE-ExternalTrustSpender", +167| "MODE-InternalDestroyer", "MODE-Fluctuating", "MODE-StableDisciplined" +168| ))); +169| +170| // behavior_labels +171| Map labels = new LinkedHashMap<>(); +172| labels.put("type", "array"); +173| labels.put("items", mapOf("type", "string")); +174| auditProps.put("behavior_labels", labels); +175| +176| // color +177| auditProps.put("color", mapOf("enum", listOf("\uD83D\uDFE2", "\uD83D\uDFE1", "\uD83D\uDD34"))); +178| +179| // timestamp +180| Map ts = new LinkedHashMap<>(); +181| ts.put("type", "string"); +182| ts.put("format", "date-time"); +183| auditProps.put("timestamp", ts); +184| +185| // payload_hash +186| Map ph = new LinkedHashMap<>(); +187| ph.put("type", "string"); +188| ph.put("pattern", "^[a-f0-9]{16}$"); +189| auditProps.put("payload_hash", ph); +190| +191| audit.put("properties", auditProps); +192| return audit; +193| } +194| +195| @SuppressWarnings("unchecked") +196| private static Map buildMetaSchema() { +197| Map meta = new LinkedHashMap<>(); +198| meta.put("type", "object"); +199| meta.put("required", listOf("adapter_version", "uid", "device", "task_type", "persona")); +200| +201| Map metaProps = new LinkedHashMap<>(); +202| metaProps.put("adapter_version", mapOf("type", "string")); +203| metaProps.put("uid", mapOf("type", "string")); +204| metaProps.put("device", mapOf("type", "string")); +205| metaProps.put("task_type", mapOf("type", "string")); +206| metaProps.put("persona", mapOf("type", "string")); +207| +208| Map genAt = new LinkedHashMap<>(); +209| genAt.put("type", "string"); +210| genAt.put("format", "date-time"); +211| metaProps.put("generated_at", genAt); +212| +213| metaProps.put("format", mapOf("const", "longhun-v\u221E")); +214| +215| meta.put("properties", metaProps); +216| return meta; +217| } +218| +219| // --- Utility helpers --- +220| +221| private static java.util.List listOf(String... values) { +222| java.util.List list = new java.util.ArrayList<>(); +223| java.util.Collections.addAll(list, values); +224| return list; +225| } +226| +227| private static Map mapOf(Object... entries) { +228| Map map = new LinkedHashMap<>(); +229| for (int i = 0; i < entries.length; i += 2) { +230| map.put((String) entries[i], entries[i + 1]); +231| } +232| return map; +233| } +234|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/ValidationResult.java b/adapters/java/src/main/java/cn/uid9622/longhun/ValidationResult.java new file mode 100644 index 0000000..9b73372 --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/ValidationResult.java @@ -0,0 +1,117 @@ +1|package cn.uid9622.longhun; +2| +3|import javax.annotation.Nullable; +4|import javax.annotation.concurrent.Immutable; +5|import java.util.ArrayList; +6|import java.util.Collections; +7|import java.util.List; +8|import java.util.Objects; +9| +10|/** +11| * Immutable result of a {@link LongHunAdapter#validate} operation. +12| * +13| *

Contains the validation status, detailed error messages, warnings, +14| * and a human-readable summary string. +15| * +16| *

This class is designed to be Kotlin-friendly with null-safety annotations +17| * and immutable collections. +18| * +19| * @since 1.0.0 +20| */ +21|@Immutable +22|public final class ValidationResult { +23| +24| private final boolean valid; +25| private final List errors; +26| private final List warnings; +27| private final String summary; +28| +29| /** +30| * Constructs a new {@code ValidationResult}. +31| * +32| * @param valid whether the wrapped payload is valid +33| * @param errors list of validation error messages (non-null, copied defensively) +34| * @param warnings list of validation warning messages (non-null, copied defensively) +35| * @param summary human-readable summary string +36| * @throws NullPointerException if errors, warnings, or summary is null +37| */ +38| public ValidationResult(boolean valid, +39| @Nullable List errors, +40| @Nullable List warnings, +41| String summary) { +42| this.valid = valid; +43| this.errors = errors != null +44| ? Collections.unmodifiableList(new ArrayList<>(errors)) +45| : Collections.emptyList(); +46| this.warnings = warnings != null +47| ? Collections.unmodifiableList(new ArrayList<>(warnings)) +48| : Collections.emptyList(); +49| this.summary = Objects.requireNonNull(summary, "summary must not be null"); +50| } +51| +52| /** +53| * Returns whether the wrapped payload is structurally valid. +54| * +55| * @return {@code true} if no errors were found +56| */ +57| public boolean isValid() { +58| return valid; +59| } +60| +61| /** +62| * Returns an unmodifiable list of error messages. +63| * +64| * @return non-null, possibly empty list of errors +65| */ +66| public List getErrors() { +67| return errors; +68| } +69| +70| /** +71| * Returns an unmodifiable list of warning messages. +72| * +73| * @return non-null, possibly empty list of warnings +74| */ +75| public List getWarnings() { +76| return warnings; +77| } +78| +79| /** +80| * Returns a human-readable summary of the validation result. +81| * +82| * @return summary string, never null +83| */ +84| public String getSummary() { +85| return summary; +86| } +87| +88| @Override +89| public boolean equals(Object o) { +90| if (this == o) return true; +91| if (o == null || getClass() != o.getClass()) return false; +92| ValidationResult that = (ValidationResult) o; +93| return valid == that.valid +94| && errors.equals(that.errors) +95| && warnings.equals(that.warnings) +96| && summary.equals(that.summary); +97| } +98| +99| @Override +100| public int hashCode() { +101| int result = (valid ? 1 : 0); +102| result = 31 * result + errors.hashCode(); +103| result = 31 * result + warnings.hashCode(); +104| result = 31 * result + summary.hashCode(); +105| return result; +106| } +107| +108| @Override +109| public String toString() { +110| return "ValidationResult{" +111| + "valid=" + valid +112| + ", errors=" + errors +113| + ", warnings=" + warnings +114| + ", summary='" + summary + '\'' +115| + '}'; +116| } +117|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/Validator.java b/adapters/java/src/main/java/cn/uid9622/longhun/Validator.java new file mode 100644 index 0000000..afb1dcb --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/Validator.java @@ -0,0 +1,332 @@ +1|package cn.uid9622.longhun; +2| +3|import com.fasterxml.jackson.databind.JsonNode; +4|import com.fasterxml.jackson.databind.node.ObjectNode; +5| +6|import javax.annotation.Nonnull; +7|import java.util.*; +8|import java.util.regex.Pattern; +9| +10|/** +11| * Validates wrapped payloads for LongHun standard compliance. +12| * +13| *

DNA: #LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷝Li-VALIDATOR-v1.0.0 +14| * +15| * @since 1.0.0 +16| */ +17|public final class Validator { +18| +19| // DNA v∞ validation regex — matches Python reference +20| private static final Pattern DNA_REGEX = Pattern.compile( +21| "^#LongHun⚡️" +22| + "([A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+·[A-Z][a-zA-Z]+)" // Four pillars +23| + "·([䷀-䷿][A-Za-z]+)" // Hexagram +24| + "-(.+)" // Body (module-action-version) +25| + "-([a-f0-9]{8})$" // Hash8 +26| ); +27| +28| private static final Set REQUIRED_TOP_KEYS = setOf("dna", "audit", "payload", "meta"); +29| private static final Set REQUIRED_AUDIT_KEYS = setOf( +30| "audit_version", "uid", "behavior_signature", +31| "behavior_pattern", "behavior_labels", "color" +32| ); +33| private static final Set REQUIRED_SIG_KEYS = setOf( +34| "P", "F", "T", "E", "C", "R", "A", "X", "Y", "Z" +35| ); +36| private static final Set VALID_COLORS = setOf("\uD83D\uDFE2", "\uD83D\uDFE1", "\uD83D\uDD34"); // 🟢🟡🔴 +37| private static final Set VALID_PATTERNS = setOf( +38| "MODE-DefensiveDefaulter", "MODE-ExternalTrustSpender", +39| "MODE-InternalDestroyer", "MODE-Fluctuating", "MODE-StableDisciplined" +40| ); +41| private static final Set VALID_P_VALUES = setOf("HasPromise", "NoPromise"); +42| private static final Set VALID_F_VALUES = setOf("Fulfilled", "Unfulfilled", "Partial"); +43| private static final Set VALID_E_VALUES = setOf("Willing", "Perfunctory", "Resentful", "Numb"); +44| private static final Set VALID_A_VALUES = setOf("Self", "Partner", "Family", "Outsider", "Public"); +45| private static final Set VALID_X_VALUES = setOf("OverExplain", "Silent", "Genuine", "Indifferent"); +46| private static final Set VALID_Y_VALUES = setOf("Changed", "Resisted", "Indifferent", "NoResponse"); +47| +48| private final List errors = new ArrayList<>(); +49| private final List warnings = new ArrayList<>(); +50| +51| /** +52| * Validates a wrapped payload. +53| * +54| * @param wrapped the wrapped payload (produced by {@link LongHunAdapter#wrap}) +55| * @return {@link ValidationResult} with valid flag, errors, warnings, and summary +56| */ +57| @Nonnull +58| public ValidationResult validate(@Nonnull ObjectNode wrapped) { +59| Objects.requireNonNull(wrapped, "wrapped must not be null"); +60| errors.clear(); +61| warnings.clear(); +62| +63| // 1. Check not empty +64| if (wrapped.size() == 0) { +65| errors.add("Input is an empty object"); +66| return result(); +67| } +68| +69| // 2. Top-level keys +70| Set keys = toSet(wrapped.fieldNames()); +71| Set missingTop = new LinkedHashSet<>(REQUIRED_TOP_KEYS); +72| missingTop.removeAll(keys); +73| if (!missingTop.isEmpty()) { +74| errors.add("Missing top-level keys: " + missingTop); +75| } +76| +77| // 3. DNA validation +78| JsonNode dnaNode = wrapped.get("dna"); +79| String dna = (dnaNode != null && dnaNode.isTextual()) ? dnaNode.asText() : ""; +80| if (dna.isEmpty()) { +81| errors.add("DNA field is empty"); +82| } else { +83| if (!DNA_REGEX.matcher(dna).matches()) { +84| String truncated = dna.length() > 60 ? dna.substring(0, 60) + "..." : dna; +85| errors.add("DNA does not match regex: " + truncated); +86| } +87| } +88| +89| // 4. Audit validation +90| JsonNode auditNode = wrapped.get("audit"); +91| Map audit = jsonNodeToMap(auditNode); +92| if (auditNode == null || !auditNode.isObject()) { +93| errors.add("Audit is not a dict"); +94| } else { +95| validateAudit(audit); +96| } +97| +98| // 5. UID consistency check +99| if (auditNode != null && auditNode.isObject()) { +100| JsonNode metaNode = wrapped.get("meta"); +101| if (metaNode != null && metaNode.isObject()) { +102| String metaUid = metaNode.has("uid") ? metaNode.get("uid").asText("") : ""; +103| String auditUid = auditNode.has("uid") ? auditNode.get("uid").asText("") : ""; +104| if (!metaUid.isEmpty() && !auditUid.isEmpty()) { +105| String auditUidClean = auditUid.replace("UID", ""); +106| if (!metaUid.equals(auditUidClean)) { +107| errors.add("UID mismatch: meta.uid=" + metaUid + ", audit.uid=" + auditUid); +108| } +109| } +110| } +111| } +112| +113| return result(); +114| } +115| +116| /** +117| * Quick check: has required keys and valid DNA format? +118| * +119| * @param wrapped the wrapped payload +120| * @return true if the payload has 'dna' and 'audit' keys and DNA matches regex +121| */ +122| public static boolean quickValidate(@Nonnull ObjectNode wrapped) { +123| Objects.requireNonNull(wrapped, "wrapped must not be null"); +124| if (!wrapped.has("dna") || !wrapped.has("audit")) { +125| return false; +126| } +127| JsonNode dnaNode = wrapped.get("dna"); +128| if (dnaNode == null || !dnaNode.isTextual()) { +129| return false; +130| } +131| return DNA_REGEX.matcher(dnaNode.asText()).matches(); +132| } +133| +134| /** +135| * Returns the DNA regex pattern used for validation. +136| * +137| * @return compiled Pattern +138| */ +139| @Nonnull +140| public static Pattern getDnaRegex() { +141| return DNA_REGEX; +142| } +143| +144| @Nonnull +145| static Set getRequiredTopKeys() { +146| return REQUIRED_TOP_KEYS; +147| } +148| +149| @Nonnull +150| static Set getRequiredAuditKeys() { +151| return REQUIRED_AUDIT_KEYS; +152| } +153| +154| @Nonnull +155| static Set getRequiredSigKeys() { +156| return REQUIRED_SIG_KEYS; +157| } +158| +159| // --- Private helpers --- +160| +161| private void validateAudit(Map audit) { +162| // Required keys +163| Set missingAudit = new LinkedHashSet<>(REQUIRED_AUDIT_KEYS); +164| missingAudit.removeAll(audit.keySet()); +165| if (!missingAudit.isEmpty()) { +166| errors.add("Missing audit keys: " + missingAudit); +167| } +168| +169| // behavior_signature +170| @SuppressWarnings("unchecked") +171| Map sig = (Map) audit.getOrDefault("behavior_signature", new HashMap<>()); +172| if (sig.isEmpty()) { +173| errors.add("behavior_signature is not a dict or is empty"); +174| } else { +175| Set missingSig = new LinkedHashSet<>(REQUIRED_SIG_KEYS); +176| missingSig.removeAll(sig.keySet()); +177| if (!missingSig.isEmpty()) { +178| errors.add("Missing signature keys: " + missingSig); +179| } else { +180| validateSigValues(sig); +181| } +182| } +183| +184| // pattern +185| String pattern = (String) audit.getOrDefault("behavior_pattern", ""); +186| if (!pattern.isEmpty() && !VALID_PATTERNS.contains(pattern)) { +187| warnings.add("Unknown behavior pattern: " + pattern); +188| } +189| +190| // color +191| String color = (String) audit.getOrDefault("color", ""); +192| if (!color.isEmpty() && !VALID_COLORS.contains(color)) { +193| warnings.add("Unknown audit color: " + color); +194| } +195| +196| // payload_hash +197| String ph = (String) audit.getOrDefault("payload_hash", ""); +198| if (!ph.isEmpty() && (ph.length() != 16 || !ph.matches("^[a-f0-9]+$"))) { +199| warnings.add("Suspicious payload_hash: " + ph); +200| } +201| } +202| +203| @SuppressWarnings("unchecked") +204| private void validateSigValues(Map sig) { +205| // P +206| String p = (String) sig.get("P"); +207| if (p != null && !VALID_P_VALUES.contains(p)) { +208| warnings.add("Invalid P: '" + p + "'"); +209| } +210| +211| // F +212| String f = (String) sig.get("F"); +213| if (f != null && !VALID_F_VALUES.contains(f)) { +214| warnings.add("Invalid F: '" + f + "'"); +215| } +216| +217| // T (number) +218| if (!(sig.get("T") instanceof Number)) { +219| warnings.add("Invalid T (number)"); +220| } +221| +222| // E +223| String e = (String) sig.get("E"); +224| if (e != null && !VALID_E_VALUES.contains(e)) { +225| warnings.add("Invalid E: '" + e + "'"); +226| } +227| +228| // C (number) +229| if (!(sig.get("C") instanceof Number)) { +230| warnings.add("Invalid C (number)"); +231| } +232| +233| // R (int >= 0) +234| Object r = sig.get("R"); +235| if (r instanceof Integer) { +236| if ((Integer) r < 0) { +237| warnings.add("Invalid R (int >= 0)"); +238| } +239| } else if (r instanceof Number) { +240| // still a number but not int +241| warnings.add("Invalid R (int >= 0)"); +242| } else { +243| warnings.add("Invalid R (int >= 0)"); +244| } +245| +246| // A +247| String a = (String) sig.get("A"); +248| if (a != null && !VALID_A_VALUES.contains(a)) { +249| warnings.add("Invalid A: '" + a + "'"); +250| } +251| +252| // X +253| String x = (String) sig.get("X"); +254| if (x != null && !VALID_X_VALUES.contains(x)) { +255| warnings.add("Invalid X: '" + x + "'"); +256| } +257| +258| // Y +259| String y = (String) sig.get("Y"); +260| if (y != null && !VALID_Y_VALUES.contains(y)) { +261| warnings.add("Invalid Y: '" + y + "'"); +262| } +263| +264| // Z (number) +265| if (!(sig.get("Z") instanceof Number)) { +266| warnings.add("Invalid Z (number)"); +267| } +268| } +269| +270| private ValidationResult result() { +271| boolean valid = errors.isEmpty(); +272| String summary; +273| if (valid) { +274| summary = "\u2705 VALID \u2014 " + warnings.size() + " warning(s)"; +275| if (!warnings.isEmpty()) { +276| String firstWarnings = String.join(", ", warnings.size() > 2 ? warnings.subList(0, 2) : warnings); +277| summary += " (" + firstWarnings + ")"; +278| } +279| } else { +280| summary = "\u274C INVALID \u2014 " + errors.size() + " error(s)"; +281| } +282| return new ValidationResult(valid, errors, warnings, summary); +283| } +284| +285| private static Set setOf(String... values) { +286| Set set = new LinkedHashSet<>(); +287| Collections.addAll(set, values); +288| return Collections.unmodifiableSet(set); +289| } +290| +291| private static Set toSet(Iterator iterator) { +292| Set set = new LinkedHashSet<>(); +293| while (iterator.hasNext()) { +294| set.add(iterator.next()); +295| } +296| return set; +297| } +298| +299| @SuppressWarnings("unchecked") +300| private static Map jsonNodeToMap(JsonNode node) { +301| if (node == null || !node.isObject()) { +302| return new HashMap<>(); +303| } +304| Map map = new LinkedHashMap<>(); +305| Iterator> fields = node.fields(); +306| while (fields.hasNext()) { +307| Map.Entry entry = fields.next(); +308| map.put(entry.getKey(), jsonNodeToValue(entry.getValue())); +309| } +310| return map; +311| } +312| +313| private static Object jsonNodeToValue(JsonNode node) { +314| if (node == null || node.isNull()) return null; +315| if (node.isTextual()) return node.asText(); +316| if (node.isBoolean()) return node.asBoolean(); +317| if (node.isInt()) return node.asInt(); +318| if (node.isLong()) return node.asLong(); +319| if (node.isDouble() || node.isFloat()) return node.asDouble(); +320| if (node.isArray()) { +321| List list = new ArrayList<>(); +322| for (JsonNode child : node) { +323| list.add(jsonNodeToValue(child)); +324| } +325| return list; +326| } +327| if (node.isObject()) { +328| return jsonNodeToMap(node); +329| } +330| return node.asText(); +331| } +332|} \ No newline at end of file diff --git a/adapters/java/src/main/java/cn/uid9622/longhun/package-info.java b/adapters/java/src/main/java/cn/uid9622/longhun/package-info.java new file mode 100644 index 0000000..4ce339a --- /dev/null +++ b/adapters/java/src/main/java/cn/uid9622/longhun/package-info.java @@ -0,0 +1,17 @@ +1|/** +2| * LongHun Standard Adapter — wrap JSON payloads with DNA traceability +3| * and seven-factor behavioral audit metadata. +4| * +5| *

DNA: #LongHun⚡️BingWu·GuiWei·JiaZi·ZiShi·䷾JiJi-ADAPTER-v1.0.0 +6| *
Author: LongHun Core · UID9622 · 龍芯北辰 +7| *
License: CC BY-NC-SA 4.0 +8| * +9| *

This adapter is an open-source shell tool. It wraps JSON payloads +10| * with DNA traceability and seven-factor behavioral audit metadata. +11| * Core compiler, training scripts, and algorithm logic are protected +12| * Chinese independent intellectual property. +13| * +14| * @since 1.0.0 +15| */ +16|@javax.annotation.ParametersAreNonnullByDefault +17|package cn.uid9622.longhun; \ No newline at end of file diff --git a/adapters/java/src/test/java/cn/uid9622/longhun/AuditWrapperTest.java b/adapters/java/src/test/java/cn/uid9622/longhun/AuditWrapperTest.java new file mode 100644 index 0000000..a3b6183 --- /dev/null +++ b/adapters/java/src/test/java/cn/uid9622/longhun/AuditWrapperTest.java @@ -0,0 +1,299 @@ +1|package cn.uid9622.longhun; +2| +3|import org.junit.jupiter.api.BeforeEach; +4|import org.junit.jupiter.api.DisplayName; +5|import org.junit.jupiter.api.Test; +6| +7|import java.util.List; +8|import java.util.Map; +9| +10|import static org.junit.jupiter.api.Assertions.*; +11| +12|/** +13| * Tests for {@link AuditWrapper}. +14| */ +15|@DisplayName("AuditWrapper") +16|class AuditWrapperTest { +17| +18| private AuditWrapper wrapper; +19| +20| @BeforeEach +21| void setUp() { +22| wrapper = new AuditWrapper("9622"); +23| } +24| +25| @Test +26| @DisplayName("wrap produces all required audit fields") +27| void wrapStructure() { +28| Map result = wrapper.wrap( +29| java.util.Collections.singletonMap("hello", "world"), +30| "code", "P04" +31| ); +32| assertTrue(result.containsKey("audit_version")); +33| assertTrue(result.containsKey("behavior_signature")); +34| assertTrue(result.containsKey("behavior_pattern")); +35| assertTrue(result.containsKey("behavior_labels")); +36| assertTrue(result.containsKey("color")); +37| assertTrue(result.containsKey("timestamp")); +38| assertTrue(result.containsKey("payload_hash")); +39| assertTrue(result.containsKey("uid")); +40| assertTrue(result.containsKey("persona")); +41| assertTrue(result.containsKey("task_type")); +42| } +43| +44| @Test +45| @DisplayName("signature contains all ten fields") +46| void signatureFields() { +47| Map result = wrapper.wrap( +48| java.util.Collections.singletonMap("x", 1), "deploy", "P04" +49| ); +50| @SuppressWarnings("unchecked") +51| Map sig = (Map) result.get("behavior_signature"); +52| assertNotNull(sig); +53| assertTrue(sig.containsKey("P")); +54| assertTrue(sig.containsKey("F")); +55| assertTrue(sig.containsKey("T")); +56| assertTrue(sig.containsKey("E")); +57| assertTrue(sig.containsKey("C")); +58| assertTrue(sig.containsKey("R")); +59| assertTrue(sig.containsKey("A")); +60| assertTrue(sig.containsKey("X")); +61| assertTrue(sig.containsKey("Y")); +62| assertTrue(sig.containsKey("Z")); +63| assertEquals("Fulfilled", sig.get("F")); +64| assertEquals("Willing", sig.get("E")); +65| } +66| +67| @Test +68| @DisplayName("default pattern is StableDisciplined") +69| void patternClassification() { +70| Map sig = new java.util.LinkedHashMap<>(); +71| sig.put("P", "HasPromise"); +72| sig.put("F", "Fulfilled"); +73| sig.put("T", 0); +74| sig.put("E", "Willing"); +75| sig.put("C", 0); +76| sig.put("R", 0); +77| sig.put("A", "Self"); +78| sig.put("X", "Genuine"); +79| sig.put("Y", "NoResponse"); +80| sig.put("Z", 1.0); +81| +82| String p = wrapper.classify(sig); +83| assertEquals("MODE-StableDisciplined", p); +84| } +85| +86| @Test +87| @DisplayName("unfulfilled+overexplain → DefensiveDefaulter") +88| void patternDefensive() { +89| Map sig = new java.util.LinkedHashMap<>(); +90| sig.put("P", "HasPromise"); +91| sig.put("F", "Unfulfilled"); +92| sig.put("T", 5); +93| sig.put("E", "Perfunctory"); +94| sig.put("C", 0); +95| sig.put("R", 2); +96| sig.put("A", "Self"); +97| sig.put("X", "OverExplain"); +98| sig.put("Y", "NoResponse"); +99| sig.put("Z", 1.0); +100| +101| String p = wrapper.classify(sig); +102| assertEquals("MODE-DefensiveDefaulter", p); +103| } +104| +105| @Test +106| @DisplayName("unfulfilled+indifferent → InternalDestroyer") +107| void patternDestroyer() { +108| Map sig = new java.util.LinkedHashMap<>(); +109| sig.put("P", "HasPromise"); +110| sig.put("F", "Unfulfilled"); +111| sig.put("T", 10); +112| sig.put("E", "Numb"); +113| sig.put("C", 0); +114| sig.put("R", 5); +115| sig.put("A", "Partner"); +116| sig.put("X", "Silent"); +117| sig.put("Y", "Indifferent"); +118| sig.put("Z", 1.0); +119| +120| String p = wrapper.classify(sig); +121| assertEquals("MODE-InternalDestroyer", p); +122| } +123| +124| @Test +125| @DisplayName("fulfilled+outsider → ExternalTrustSpender") +126| void patternExternalTrust() { +127| Map sig = new java.util.LinkedHashMap<>(); +128| sig.put("P", "HasPromise"); +129| sig.put("F", "Fulfilled"); +130| sig.put("T", 0); +131| sig.put("E", "Willing"); +132| sig.put("C", 0); +133| sig.put("R", 0); +134| sig.put("A", "Outsider"); +135| sig.put("X", "Genuine"); +136| sig.put("Y", "NoResponse"); +137| sig.put("Z", 1.0); +138| +139| String p = wrapper.classify(sig); +140| assertEquals("MODE-ExternalTrustSpender", p); +141| } +142| +143| @Test +144| @DisplayName("Z > 2.0 → Fluctuating") +145| void patternFluctuating() { +146| Map sig = new java.util.LinkedHashMap<>(); +147| sig.put("P", "HasPromise"); +148| sig.put("F", "Fulfilled"); +149| sig.put("T", 0); +150| sig.put("E", "Willing"); +151| sig.put("C", 0); +152| sig.put("R", 0); +153| sig.put("A", "Self"); +154| sig.put("X", "Genuine"); +155| sig.put("Y", "NoResponse"); +156| sig.put("Z", 3.5); +157| +158| String p = wrapper.classify(sig); +159| assertEquals("MODE-Fluctuating", p); +160| } +161| +162| @Test +163| @DisplayName("labels contain 7F- prefixes and MODE suffix") +164| void behaviorLabels() { +165| Map result = wrapper.wrap( +166| java.util.Collections.singletonMap("test", true), "audit", "P04" +167| ); +168| @SuppressWarnings("unchecked") +169| List labels = (List) result.get("behavior_labels"); +170| assertNotNull(labels); +171| assertFalse(labels.isEmpty()); +172| assertTrue(labels.stream().anyMatch(l -> l.startsWith("7F-"))); +173| assertTrue(labels.stream().anyMatch(l -> l.startsWith("MODE-"))); +174| } +175| +176| @Test +177| @DisplayName("color is one of 🟢🟡🔴") +178| void auditColor() { +179| Map result = wrapper.wrap( +180| java.util.Collections.singletonMap("x", 1), "default", "P04" +181| ); +182| String color = (String) result.get("color"); +183| assertTrue("\uD83D\uDFE2\uD83D\uDFE1\uD83D\uDD34".contains(color), +184| "color should be 🟢🟡🔴 but got: " + color); +185| } +186| +187| @Test +188| @DisplayName("payload hash is 16 hex chars") +189| void payloadHash() { +190| Map payload = new java.util.LinkedHashMap<>(); +191| payload.put("code", "def hello(): return 'hello'"); +192| payload.put("language", "python"); +193| payload.put("metadata", java.util.Collections.singletonMap("author", "test")); +194| payload.put("tags", java.util.Arrays.asList("ai", "ml", "longhun")); +195| +196| Map result = wrapper.wrap(payload, "code", "P04-Luban"); +197| String ph = (String) result.get("payload_hash"); +198| assertNotNull(ph); +199| assertEquals(16, ph.length()); +200| assertTrue(ph.matches("[a-f0-9]{16}")); +201| } +202| +203| @Test +204| @DisplayName("audit_version is v1.0") +205| void auditVersion() { +206| Map result = wrapper.wrap("test", "default", "P04"); +207| assertEquals("v1.0", result.get("audit_version")); +208| } +209| +210| @Test +211| @DisplayName("uid is prefixed with UID") +212| void uidPrefix() { +213| Map result = wrapper.wrap("test", "default", "P04"); +214| assertEquals("UID9622", result.get("uid")); +215| } +216| +217| @Test +218| @DisplayName("persona is preserved") +219| void personaPreserved() { +220| Map result = wrapper.wrap("test", "default", "P14-Lvmeng"); +221| assertEquals("P14-Lvmeng", result.get("persona")); +222| } +223| +224| @Test +225| @DisplayName("task_type is preserved") +226| void taskTypePreserved() { +227| Map result = wrapper.wrap("test", "deploy", "P04"); +228| assertEquals("deploy", result.get("task_type")); +229| } +230| +231| @Test +232| @DisplayName("timestamp is ISO format") +233| void timestampFormat() { +234| Map result = wrapper.wrap("test", "default", "P04"); +235| String ts = (String) result.get("timestamp"); +236| assertNotNull(ts); +237| assertTrue(ts.contains("T"), "timestamp should be ISO format"); +238| } +239| +240| @Test +241| @DisplayName("InternalDestroyer → 🔴 color") +242| void colorRed() { +243| String color = wrapper.determineColor("MODE-InternalDestroyer", 5); +244| assertEquals("\uD83D\uDD34", color); +245| } +246| +247| @Test +248| @DisplayName("Fluctuating with R>3 → 🟡 color") +249| void colorYellowFluctuating() { +250| String color = wrapper.determineColor("MODE-Fluctuating", 5); +251| assertEquals("\uD83D\uDFE1", color); +252| } +253| +254| @Test +255| @DisplayName("DefensiveDefaulter with R>2 → 🟡 color") +256| void colorYellowDefensive() { +257| String color = wrapper.determineColor("MODE-DefensiveDefaulter", 3); +258| assertEquals("\uD83D\uDFE1", color); +259| } +260| +261| @Test +262| @DisplayName("StableDisciplined → 🟢 color") +263| void colorGreen() { +264| String color = wrapper.determineColor("MODE-StableDisciplined", 0); +265| assertEquals("\uD83D\uDFE2", color); +266| } +267| +268| @Test +269| @DisplayName("Fluctuating with R≤3 → 🟢 color") +270| void colorGreenFluctuatingLowRepeat() { +271| String color = wrapper.determineColor("MODE-Fluctuating", 2); +272| assertEquals("\uD83D\uDFE2", color); +273| } +274| +275| @Test +276| @DisplayName("DefensiveDefaulter with R≤2 → 🟢 color") +277| void colorGreenDefensiveLowRepeat() { +278| String color = wrapper.determineColor("MODE-DefensiveDefaulter", 1); +279| assertEquals("\uD83D\uDFE2", color); +280| } +281| +282| @Test +283| @DisplayName("wrap with null payload throws NPE") +284| void wrapNullPayload() { +285| assertThrows(NullPointerException.class, () -> wrapper.wrap(null, "code", "P04")); +286| } +287| +288| @Test +289| @DisplayName("wrap with null taskType throws NPE") +290| void wrapNullTaskType() { +291| assertThrows(NullPointerException.class, () -> wrapper.wrap("data", null, "P04")); +292| } +293| +294| @Test +295| @DisplayName("wrap with null persona throws NPE") +296| void wrapNullPersona() { +297| assertThrows(NullPointerException.class, () -> wrapper.wrap("data", "code", null)); +298| } +299|} \ No newline at end of file diff --git a/adapters/java/src/test/java/cn/uid9622/longhun/DNAGeneratorTest.java b/adapters/java/src/test/java/cn/uid9622/longhun/DNAGeneratorTest.java new file mode 100644 index 0000000..5883442 --- /dev/null +++ b/adapters/java/src/test/java/cn/uid9622/longhun/DNAGeneratorTest.java @@ -0,0 +1,232 @@ +1|package cn.uid9622.longhun; +2| +3|import com.fasterxml.jackson.databind.node.ObjectNode; +4|import org.junit.jupiter.api.BeforeEach; +5|import org.junit.jupiter.api.DisplayName; +6|import org.junit.jupiter.api.Test; +7| +8|import java.util.Map; +9| +10|import static org.junit.jupiter.api.Assertions.*; +11| +12|/** +13| * Tests for {@link DNAGenerator}. +14| */ +15|@DisplayName("DNAGenerator") +16|class DNAGeneratorTest { +17| +18| private DNAGenerator gen; +19| +20| @BeforeEach +21| void setUp() { +22| gen = new DNAGenerator("9622", "HM-9622-001", "Asia/Shanghai"); +23| } +24| +25| @Test +26| @DisplayName("generate default task produces valid DNA prefix") +27| void generateDefault() { +28| String dna = gen.generate("default", "WRAP", "V1.0"); +29| assertNotNull(dna); +30| assertTrue(dna.startsWith("#LongHun⚡️"), "DNA should start with #LongHun⚡️"); +31| assertTrue(dna.contains("ADAPTER-DEFAULT-WRAP-V1.0"), "DNA should contain module path"); +32| assertTrue(dna.matches(".*-[a-f0-9]{8}$"), "DNA should end with 8-char hex hash"); +33| } +34| +35| @Test +36| @DisplayName("generate code task produces correct body") +37| void generateCodeTask() { +38| String dna = gen.generate("code", "GENERATE", "v2.0"); +39| assertTrue(dna.startsWith("#LongHun⚡️")); +40| assertTrue(dna.contains("ADAPTER-CODE-GENERATE-V2.0")); +41| } +42| +43| @Test +44| @DisplayName("generate deploy task produces correct body") +45| void generateDeployTask() { +46| String dna = gen.generate("deploy", "DEPLOY", null); +47| assertTrue(dna.contains("#LongHun⚡️")); +48| assertTrue(dna.contains("ADAPTER-DEPLOY-DEPLOY-V1.0")); +49| } +50| +51| @Test +52| @DisplayName("generate audit task produces non-null long DNA") +53| void generateAuditTask() { +54| String dna = gen.generate("audit", "AUDIT", null); +55| assertNotNull(dna); +56| assertTrue(dna.length() > 30); +57| } +58| +59| @Test +60| @DisplayName("generate multiple tasks all produce valid regex-matching DNA") +61| void generateMultipleTasks() { +62| String[] tasks = {"default", "code", "deploy", "audit", "security", "archive"}; +63| for (String task : tasks) { +64| String dna = gen.generate(task, "WRAP", "V1.0"); +65| assertNotNull(dna, "DNA for " + task + " should not be null"); +66| assertTrue(dna.startsWith("#LongHun⚡️"), "DNA for " + task + " should start with prefix"); +67| } +68| } +69| +70| @Test +71| @DisplayName("computeStemBranch returns all four pillars") +72| void computeStemBranch() { +73| java.time.ZonedDateTime dt = java.time.ZonedDateTime.of( +74| 2026, 7, 24, 13, 0, 0, 0, +75| java.time.ZoneId.of("Asia/Shanghai") +76| ); +77| Map stem = gen.computeStemBranch(dt); +78| assertNotNull(stem.get("year")); +79| assertNotNull(stem.get("month")); +80| assertNotNull(stem.get("day")); +81| assertNotNull(stem.get("shichen")); +82| assertTrue(stem.get("year").length() > 0); +83| assertTrue(stem.get("month").length() > 0); +84| assertEquals("WeiShi", stem.get("shichen"), "13:00 → WeiShi"); +85| } +86| +87| @Test +88| @DisplayName("computeStemBranch at midnight returns ZiShi") +89| void computeStemBranchMidnight() { +90| java.time.ZonedDateTime dt = java.time.ZonedDateTime.of( +91| 2026, 7, 24, 0, 0, 0, 0, +92| java.time.ZoneId.of("Asia/Shanghai") +93| ); +94| Map stem = gen.computeStemBranch(dt); +95| assertEquals("ZiShi", stem.get("shichen"), "00:00 → ZiShi"); +96| } +97| +98| @Test +99| @DisplayName("computeStemBranch at 23:00 returns ZiShi") +100| void computeStemBranchLateNight() { +101| java.time.ZonedDateTime dt = java.time.ZonedDateTime.of( +102| 2026, 7, 24, 23, 30, 0, 0, +103| java.time.ZoneId.of("Asia/Shanghai") +104| ); +105| Map stem = gen.computeStemBranch(dt); +106| assertEquals("ZiShi", stem.get("shichen"), "23:30 → ZiShi"); +107| } +108| +109| @Test +110| @DisplayName("selectHexagram for audit returns Li") +111| void selectHexagramAudit() { +112| Map hex = gen.selectHexagram("audit"); +113| assertNotNull(hex); +114| assertEquals("Li", hex.get("enName")); +115| } +116| +117| @Test +118| @DisplayName("selectHexagram for deploy returns Xun") +119| void selectHexagramDeploy() { +120| Map hex = gen.selectHexagram("deploy"); +121| assertNotNull(hex); +122| assertEquals("Xun", hex.get("enName")); +123| } +124| +125| @Test +126| @DisplayName("selectHexagram for code returns Kan") +127| void selectHexagramCode() { +128| Map hex = gen.selectHexagram("code"); +129| assertNotNull(hex); +130| assertEquals("Kan", hex.get("enName")); +131| } +132| +133| @Test +134| @DisplayName("selectHexagram for unknown task returns Qian (default)") +135| void selectHexagramUnknown() { +136| Map hex = gen.selectHexagram("unknown-task"); +137| assertNotNull(hex); +138| assertTrue(hex.containsKey("enName")); +139| } +140| +141| @Test +142| @DisplayName("selectHexagram for security returns Zhen") +143| void selectHexagramSecurity() { +144| Map hex = gen.selectHexagram("security"); +145| assertEquals("Zhen", hex.get("enName")); +146| } +147| +148| @Test +149| @DisplayName("selectHexagram for privacy returns Gen") +150| void selectHexagramPrivacy() { +151| Map hex = gen.selectHexagram("privacy"); +152| assertEquals("Gen", hex.get("enName")); +153| } +154| +155| @Test +156| @DisplayName("selectHexagram for trust returns Dui") +157| void selectHexagramTrust() { +158| Map hex = gen.selectHexagram("trust"); +159| assertEquals("Dui", hex.get("enName")); +160| } +161| +162| @Test +163| @DisplayName("selectHexagram for complete returns JiJi") +164| void selectHexagramComplete() { +165| Map hex = gen.selectHexagram("complete"); +166| assertEquals("JiJi", hex.get("enName")); +167| } +168| +169| @Test +170| @DisplayName("selectHexagram for progress returns WeiJi") +171| void selectHexagramProgress() { +172| Map hex = gen.selectHexagram("progress"); +173| assertEquals("WeiJi", hex.get("enName")); +174| } +175| +176| @Test +177| @DisplayName("hash8 length is always 8") +178| void hash8Length() { +179| String dna = gen.generate("test", "TEST", null); +180| String hash8 = dna.substring(dna.length() - 8); +181| assertEquals(8, hash8.length()); +182| assertTrue(hash8.matches("[a-f0-9]{8}")); +183| } +184| +185| @Test +186| @DisplayName("different tasks may produce different hexagrams") +187| void differentTasksDifferentHexagrams() { +188| Map hexAudit = gen.selectHexagram("audit"); +189| Map hexDeploy = gen.selectHexagram("deploy"); +190| assertNotNull(hexAudit); +191| assertNotNull(hexDeploy); +192| } +193| +194| @Test +195| @DisplayName("getHexagrams returns all 14 hexagrams") +196| void getHexagramsCount() { +197| assertEquals(14, DNAGenerator.getHexagrams().size()); +198| } +199| +200| @Test +201| @DisplayName("getTaskHexagramMap contains all expected task types") +202| void getTaskHexagramMap() { +203| Map map = DNAGenerator.getTaskHexagramMap(); +204| assertTrue(map.containsKey("default")); +205| assertTrue(map.containsKey("code")); +206| assertTrue(map.containsKey("deploy")); +207| assertTrue(map.containsKey("audit")); +208| assertTrue(map.containsKey("security")); +209| assertTrue(map.containsKey("archive")); +210| } +211| +212| @Test +213| @DisplayName("constructor stores uid, device, locale") +214| void constructor() { +215| DNAGenerator g = new DNAGenerator("1234", "DEVICE-001", "America/New_York"); +216| assertEquals("1234", g.getUid()); +217| assertEquals("DEVICE-001", g.getDevice()); +218| assertEquals("America/New_York", g.getLocale()); +219| } +220| +221| @Test +222| @DisplayName("generate with null taskType throws NPE") +223| void generateNullTaskType() { +224| assertThrows(NullPointerException.class, () -> gen.generate(null, "WRAP", "V1.0")); +225| } +226| +227| @Test +228| @DisplayName("generate with null action throws NPE") +229| void generateNullAction() { +230| assertThrows(NullPointerException.class, () -> gen.generate("default", null, "V1.0")); +231| } +232|} \ No newline at end of file diff --git a/adapters/java/src/test/java/cn/uid9622/longhun/LongHunAdapterTest.java b/adapters/java/src/test/java/cn/uid9622/longhun/LongHunAdapterTest.java new file mode 100644 index 0000000..b9808ab --- /dev/null +++ b/adapters/java/src/test/java/cn/uid9622/longhun/LongHunAdapterTest.java @@ -0,0 +1,319 @@ +1|package cn.uid9622.longhun; +2| +3|import com.fasterxml.jackson.databind.ObjectMapper; +4|import com.fasterxml.jackson.databind.node.ObjectNode; +5|import org.junit.jupiter.api.BeforeEach; +6|import org.junit.jupiter.api.DisplayName; +7|import org.junit.jupiter.api.Test; +8| +9|import java.util.Map; +10| +11|import static org.junit.jupiter.api.Assertions.*; +12| +13|/** +14| * Tests for {@link LongHunAdapter}. +15| */ +16|@DisplayName("LongHunAdapter") +17|class LongHunAdapterTest { +18| +19| private static final ObjectMapper MAPPER = new ObjectMapper(); +20| private LongHunAdapter adapter; +21| +22| @BeforeEach +23| void setUp() { +24| adapter = new LongHunAdapter("9622", "HM-9622-001"); +25| } +26| +27| @Test +28| @DisplayName("wrap produces all four top-level keys") +29| void wrapProducesTopLevelKeys() { +30| ObjectNode result = adapter.wrap("hello", "code", "P04"); +31| assertNotNull(result); +32| assertTrue(result.has("dna")); +33| assertTrue(result.has("audit")); +34| assertTrue(result.has("payload")); +35| assertTrue(result.has("meta")); +36| } +37| +38| @Test +39| @DisplayName("wrap preserves payload data") +40| void wrapPreservesPayload() { +41| Map data = mapOf("name", "test", "value", 42); +42| ObjectNode result = adapter.wrap(data, "code", "P04"); +43| assertEquals("test", result.get("payload").get("name").asText()); +44| assertEquals(42, result.get("payload").get("value").asInt()); +45| } +46| +47| @Test +48| @DisplayName("wrap dna starts with prefix") +49| void wrapDnaPrefix() { +50| ObjectNode result = adapter.wrap("test", "code", "P04"); +51| String dna = result.get("dna").asText(); +52| assertTrue(dna.startsWith("#LongHun⚡️")); +53| } +54| +55| @Test +56| @DisplayName("wrap audit has behavior_signature") +57| void wrapAuditSignature() { +58| ObjectNode result = adapter.wrap("test", "code", "P04"); +59| assertTrue(result.get("audit").has("behavior_signature")); +60| } +61| +62| @Test +63| @DisplayName("wrap meta has adapter_version") +64| void wrapMetaVersion() { +65| ObjectNode result = adapter.wrap("test", "code", "P04"); +66| assertEquals("1.0.0", result.get("meta").get("adapter_version").asText()); +67| } +68| +69| @Test +70| @DisplayName("wrap meta has uid matching constructor") +71| void wrapMetaUid() { +72| ObjectNode result = adapter.wrap("test", "code", "P04"); +73| assertEquals("9622", result.get("meta").get("uid").asText()); +74| } +75| +76| @Test +77| @DisplayName("wrap meta has device matching constructor") +78| void wrapMetaDevice() { +79| ObjectNode result = adapter.wrap("test", "code", "P04"); +80| assertEquals("HM-9622-001", result.get("meta").get("device").asText()); +81| } +82| +83| @Test +84| @DisplayName("wrap meta has task_type") +85| void wrapMetaTaskType() { +86| ObjectNode result = adapter.wrap("test", "audit", "P04"); +87| assertEquals("audit", result.get("meta").get("task_type").asText()); +88| } +89| +90| @Test +91| @DisplayName("wrap meta has persona") +92| void wrapMetaPersona() { +93| ObjectNode result = adapter.wrap("test", "code", "P04-Luban"); +94| assertEquals("P04-Luban", result.get("meta").get("persona").asText()); +95| } +96| +97| @Test +98| @DisplayName("wrap meta has format longhun-v∞") +99| void wrapMetaFormat() { +100| ObjectNode result = adapter.wrap("test", "code", "P04"); +101| assertEquals("longhun-v∞", result.get("meta").get("format").asText()); +102| } +103| +104| @Test +105| @DisplayName("wrap meta has generated_at timestamp") +106| void wrapMetaTimestamp() { +107| ObjectNode result = adapter.wrap("test", "code", "P04"); +108| assertTrue(result.get("meta").get("generated_at").asText().contains("T")); +109| } +110| +111| @Test +112| @DisplayName("wrap with custom locale") +113| void wrapCustomLocale() { +114| LongHunAdapter custom = new LongHunAdapter("9622", "HM-9622-002", "America/New_York"); +115| ObjectNode result = custom.wrap("test", "code", "P04"); +116| assertTrue(result.get("dna").asText().startsWith("#LongHun⚡️")); +117| } +118| +119| @Test +120| @DisplayName("wrap with null data throws NPE") +121| void wrapNullData() { +122| assertThrows(NullPointerException.class, () -> adapter.wrap(null, "code", "P04")); +123| } +124| +125| @Test +126| @DisplayName("wrap with null taskType throws NPE") +127| void wrapNullTaskType() { +128| assertThrows(NullPointerException.class, () -> adapter.wrap("data", null, "P04")); +129| } +130| +131| @Test +132| @DisplayName("wrap with null persona throws NPE") +133| void wrapNullPersona() { +134| assertThrows(NullPointerException.class, () -> adapter.wrap("data", "code", null)); +135| } +136| +137| @Test +138| @DisplayName("getSchemas returns non-null map") +139| void getSchemasNonNull() { +140| Map schemas = adapter.getSchemas(); +141| assertNotNull(schemas); +142| assertEquals(2, schemas.size()); +143| } +144| +145| @Test +146| @DisplayName("getVersion returns 1.0.0") +147| void getVersion() { +148| assertEquals("1.0.0", LongHunAdapter.getVersion()); +149| } +150| +151| @Test +152| @DisplayName("getAuthor returns author string") +153| void getAuthor() { +154| String author = LongHunAdapter.getAuthor(); +155| assertNotNull(author); +156| assertTrue(author.contains("LongHun")); +157| } +158| +159| @Test +160| @DisplayName("getLicense returns CC BY-NC-SA 4.0") +161| void getLicense() { +162| assertEquals("CC BY-NC-SA 4.0", LongHunAdapter.getLicense()); +163| } +164| +165| @Test +166| @DisplayName("getDna returns DNA string") +167| void getDna() { +168| String dna = LongHunAdapter.getDna(); +169| assertNotNull(dna); +170| assertTrue(dna.startsWith("#LongHun⚡️")); +171| } +172| +173| @Test +174| @DisplayName("adapter has correct uid") +175| void getUid() { +176| assertEquals("9622", adapter.getUid()); +177| } +178| +179| @Test +180| @DisplayName("adapter has correct device") +181| void getDevice() { +182| assertEquals("HM-9622-001", adapter.getDevice()); +183| } +184| +185| @Test +186| @DisplayName("adapter has correct locale") +187| void getLocale() { +188| assertEquals("Asia/Shanghai", adapter.getLocale()); +189| } +190| +191| @Test +192| @DisplayName("getDnaGenerator returns non-null") +193| void getDnaGenerator() { +194| assertNotNull(adapter.getDnaGenerator()); +195| } +196| +197| @Test +198| @DisplayName("getAuditWrapper returns non-null") +199| void getAuditWrapper() { +200| assertNotNull(adapter.getAuditWrapper()); +201| } +202| +203| @Test +204| @DisplayName("getValidator returns non-null") +205| void getValidator() { +206| assertNotNull(adapter.getValidator()); +207| } +208| +209| @Test +210| @DisplayName("wrap with extended signature") +211| void wrapExtended() { +212| ObjectNode result = adapter.wrap("data", "code", "P04", "GENERATE", "v2.0"); +213| String dna = result.get("dna").asText(); +214| assertTrue(dna.contains("ADAPTER-CODE-GENERATE-V2.0")); +215| } +216| +217| @Test +218| @DisplayName("wrap with complex nested payload") +219| void wrapComplexPayload() { +220| Map data = mapOf( +221| "level1", mapOf( +222| "level2", mapOf( +223| "value", 42 +224| ) +225| ), +226| "array", java.util.Arrays.asList(1, 2, 3) +227| ); +228| ObjectNode result = adapter.wrap(data, "code", "P04"); +229| assertEquals(42, result.get("payload").get("level1").get("level2").get("value").asInt()); +230| } +231| +232| @Test +233| @DisplayName("wrap with numeric payload") +234| void wrapNumericPayload() { +235| ObjectNode result = adapter.wrap(42, "code", "P04"); +236| assertEquals(42, result.get("payload").asInt()); +237| } +238| +239| @Test +240| @DisplayName("wrap with boolean payload") +241| void wrapBooleanPayload() { +242| ObjectNode result = adapter.wrap(true, "code", "P04"); +243| assertTrue(result.get("payload").asBoolean()); +244| } +245| +246| @Test +247| @DisplayName("wrap with list payload") +248| void wrapListPayload() { +249| ObjectNode result = adapter.wrap(java.util.Arrays.asList("a", "b", "c"), "code", "P04"); +250| assertTrue(result.get("payload").isArray()); +251| assertEquals(3, result.get("payload").size()); +252| } +253| +254| @Test +255| @DisplayName("wrap with null version defaults to V1.0") +256| void wrapNullVersion() { +257| ObjectNode result = adapter.wrap("test", "code", "P04", "WRAP", null); +258| String dna = result.get("dna").asText(); +259| assertTrue(dna.contains("-WRAP-V1.0"), "DNA should contain V1.0: " + dna); +260| } +261| +262| @Test +263| @DisplayName("wrap produces valid full cycle") +264| void wrapValidateCycle() { +265| ObjectNode result = adapter.wrap(mapOf("key", "value"), "default", "P04"); +266| ValidationResult validation = adapter.validate(result); +267| assertTrue(validation.isValid()); +268| } +269| +270| @Test +271| @DisplayName("constructor with null uid throws NPE") +272| void constructorNullUid() { +273| assertThrows(NullPointerException.class, () -> new LongHunAdapter(null, "device")); +274| } +275| +276| @Test +277| @DisplayName("constructor with null device throws NPE") +278| void constructorNullDevice() { +279| assertThrows(NullPointerException.class, () -> new LongHunAdapter("uid", null)); +280| } +281| +282| // --- Schemas tests --- +283| +284| @Test +285| @DisplayName("Schemas.getDnaSchema returns non-null") +286| void schemasGetDnaSchema() { +287| assertNotNull(Schemas.getDnaSchema()); +288| } +289| +290| @Test +291| @DisplayName("Schemas.getAuditSchema returns non-null") +292| void schemasGetAuditSchema() { +293| assertNotNull(Schemas.getAuditSchema()); +294| } +295| +296| @Test +297| @DisplayName("Schemas.getDnaSchema has correct $schema") +298| void schemasDnaSchemaField() { +299| Map schema = Schemas.getDnaSchema(); +300| assertEquals("https://json-schema.org/draft/2020-12/schema", schema.get("$schema")); +301| } +302| +303| @Test +304| @DisplayName("Schemas.getAuditSchema has correct $schema") +305| void schemasAuditSchemaField() { +306| Map schema = Schemas.getAuditSchema(); +307| assertEquals("https://json-schema.org/draft/2020-12/schema", schema.get("$schema")); +308| } +309| +310| // --- Helper --- +311| +312| private static Map mapOf(Object... entries) { +313| Map map = new java.util.LinkedHashMap<>(); +314| for (int i = 0; i < entries.length; i += 2) { +315| map.put((String) entries[i], entries[i + 1]); +316| } +317| return map; +318| } +319|} \ No newline at end of file diff --git a/adapters/java/src/test/java/cn/uid9622/longhun/ValidatorTest.java b/adapters/java/src/test/java/cn/uid9622/longhun/ValidatorTest.java new file mode 100644 index 0000000..73bc9c8 --- /dev/null +++ b/adapters/java/src/test/java/cn/uid9622/longhun/ValidatorTest.java @@ -0,0 +1,339 @@ +1|package cn.uid9622.longhun; +2| +3|import com.fasterxml.jackson.databind.ObjectMapper; +4|import com.fasterxml.jackson.databind.node.ObjectNode; +5|import org.junit.jupiter.api.BeforeEach; +6|import org.junit.jupiter.api.DisplayName; +7|import org.junit.jupiter.api.Test; +8| +9|import java.util.Map; +10| +11|import static org.junit.jupiter.api.Assertions.*; +12| +13|/** +14| * Tests for {@link Validator}. +15| */ +16|@DisplayName("Validator") +17|class ValidatorTest { +18| +19| private static final ObjectMapper MAPPER = new ObjectMapper(); +20| private LongHunAdapter adapter; +21| private Validator validator; +22| +23| @BeforeEach +24| void setUp() { +25| adapter = new LongHunAdapter("9622", "HM-9622-001"); +26| validator = new Validator(); +27| } +28| +29| @Test +30| @DisplayName("full cycle valid") +31| void fullCycleValid() { +32| ObjectNode wrapped = adapter.wrap( +33| mapOf("action", "deploy", "target", "portal"), +34| "deploy", "P14-Lvmeng" +35| ); +36| ValidationResult result = adapter.validate(wrapped); +37| assertTrue(result.isValid(), "valid: " + result.getSummary()); +38| } +39| +40| @Test +41| @DisplayName("multiple code payloads all validate") +42| void multipleCodePayloads() { +43| String[] codes = { +44| "print(\"hello\")", +45| "def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)", +46| "import numpy as np" +47| }; +48| for (String code : codes) { +49| ObjectNode wrapped = adapter.wrap( +50| mapOf("code", code, "language", "python"), +51| "code", "P04-Luban" +52| ); +53| assertTrue(adapter.validate(wrapped).isValid(), "Failed for code: " + code); +54| } +55| } +56| +57| @Test +58| @DisplayName("quickValidate passes on valid wrapped payload") +59| void quickValidate() { +60| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +61| assertTrue(Validator.quickValidate(wrapped)); +62| } +63| +64| @Test +65| @DisplayName("quickValidate rejects empty object") +66| void quickValidateRejectsEmpty() { +67| assertFalse(Validator.quickValidate(MAPPER.createObjectNode())); +68| } +69| +70| @Test +71| @DisplayName("quickValidate rejects partial object") +72| void quickValidateRejectsPartial() { +73| ObjectNode obj = MAPPER.createObjectNode(); +74| obj.put("dna", "bad"); +75| assertFalse(Validator.quickValidate(obj)); +76| } +77| +78| @Test +79| @DisplayName("validate rejects empty object") +80| void emptyPayload() { +81| ValidationResult result = adapter.validate(MAPPER.createObjectNode()); +82| assertFalse(result.isValid()); +83| } +84| +85| @Test +86| @DisplayName("validate rejects invalid DNA") +87| void invalidDna() { +88| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +89| wrapped.put("dna", "#BadDNA-xxx"); +90| ValidationResult result = adapter.validate(wrapped); +91| assertFalse(result.isValid()); +92| } +93| +94| @Test +95| @DisplayName("validate rejects missing audit key") +96| void missingAudit() { +97| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +98| wrapped.remove("audit"); +99| ValidationResult result = adapter.validate(wrapped); +100| assertFalse(result.isValid()); +101| } +102| +103| @Test +104| @DisplayName("validate rejects missing payload key") +105| void missingPayload() { +106| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +107| wrapped.remove("payload"); +108| ValidationResult result = adapter.validate(wrapped); +109| assertFalse(result.isValid()); +110| } +111| +112| @Test +113| @DisplayName("validate rejects missing meta key") +114| void missingMeta() { +115| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +116| wrapped.remove("meta"); +117| ValidationResult result = adapter.validate(wrapped); +118| assertFalse(result.isValid()); +119| } +120| +121| @Test +122| @DisplayName("validate detects UID mismatch") +123| void uidMismatch() { +124| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +125| ((ObjectNode) wrapped.get("audit")).put("uid", "UID9876"); +126| ValidationResult result = adapter.validate(wrapped); +127| assertFalse(result.isValid()); +128| } +129| +130| @Test +131| @DisplayName("validate produces warnings for invalid signature fields") +132| void invalidSignatureFields() { +133| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +134| ((ObjectNode) wrapped.get("audit").get("behavior_signature")).put("F", "INVALID_VALUE"); +135| ValidationResult result = adapter.validate(wrapped); +136| assertTrue(result.getWarnings().size() > 0, "warnings for invalid fields"); +137| } +138| +139| @Test +140| @DisplayName("validate multiple wraps with different tasks") +141| void multipleWraps() { +142| Object[][] tasks = { +143| {mapOf("op", "scan"), "audit", "P05-Shangdi"}, +144| {mapOf("op", "build"), "code", "P04-Luban"}, +145| {mapOf("op", "deploy"), "deploy", "P14-Lvmeng"}, +146| }; +147| for (Object[] task : tasks) { +148| @SuppressWarnings("unchecked") +149| Map data = (Map) task[0]; +150| String taskType = (String) task[1]; +151| String persona = (String) task[2]; +152| ObjectNode wrapped = adapter.wrap(data, taskType, persona); +153| ValidationResult result = adapter.validate(wrapped); +154| assertTrue(result.isValid(), taskType + "/" + persona + ": " + result.getSummary()); +155| } +156| } +157| +158| @Test +159| @DisplayName("validate with null input throws NPE") +160| void validateNull() { +161| assertThrows(NullPointerException.class, () -> adapter.validate(null)); +162| } +163| +164| @Test +165| @DisplayName("schema contains dna_schema and audit_schema") +166| void getSchemas() { +167| Map schemas = adapter.getSchemas(); +168| assertTrue(schemas.containsKey("dna_schema")); +169| assertTrue(schemas.containsKey("audit_schema")); +170| assertTrue(schemas.get("dna_schema") instanceof Map); +171| assertTrue(schemas.get("audit_schema") instanceof Map); +172| } +173| +174| @Test +175| @DisplayName("dna_schema has correct structure") +176| void dnaSchemaStructure() { +177| Map schemas = adapter.getSchemas(); +178| @SuppressWarnings("unchecked") +179| Map dnaSchema = (Map) schemas.get("dna_schema"); +180| assertEquals("object", dnaSchema.get("type")); +181| assertTrue(dnaSchema.containsKey("properties")); +182| assertTrue(dnaSchema.containsKey("required")); +183| } +184| +185| @Test +186| @DisplayName("audit_schema has correct structure") +187| void auditSchemaStructure() { +188| Map schemas = adapter.getSchemas(); +189| @SuppressWarnings("unchecked") +190| Map auditSchema = (Map) schemas.get("audit_schema"); +191| assertEquals("object", auditSchema.get("type")); +192| assertTrue(auditSchema.containsKey("properties")); +193| } +194| +195| @Test +196| @DisplayName("validate detects missing top-level keys") +197| void missingTopLevelKeys() { +198| ObjectNode bad = MAPPER.createObjectNode(); +199| bad.put("dna", "#LongHun⚡️BingWu·GuiWei·JiaZi·WeiShi·䷾JiJi-ADAPTER-TEST-WRAP-V1.0-a3f8c1d9"); +200| // missing audit, payload, meta +201| ValidationResult result = adapter.validate(bad); +202| assertFalse(result.isValid()); +203| assertTrue(result.getErrors().stream().anyMatch(e -> e.contains("Missing top-level keys"))); +204| } +205| +206| @Test +207| @DisplayName("validate with empty DNA field") +208| void emptyDna() { +209| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +210| wrapped.put("dna", ""); +211| ValidationResult result = adapter.validate(wrapped); +212| assertFalse(result.isValid()); +213| assertTrue(result.getErrors().stream().anyMatch(e -> e.contains("DNA field is empty"))); +214| } +215| +216| @Test +217| @DisplayName("validate with null audit field") +218| void nullAudit() { +219| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +220| wrapped.set("audit", MAPPER.createObjectNode()); +221| // Remove behavior_signature from audit +222| ValidationResult result = adapter.validate(wrapped); +223| assertFalse(result.isValid()); +224| } +225| +226| @Test +227| @DisplayName("validate detects missing audit keys") +228| void missingAuditKeys() { +229| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +230| ObjectNode audit = (ObjectNode) wrapped.get("audit"); +231| audit.remove("behavior_pattern"); +232| ValidationResult result = adapter.validate(wrapped); +233| assertFalse(result.isValid()); +234| } +235| +236| @Test +237| @DisplayName("validate detects missing signature keys") +238| void missingSignatureKeys() { +239| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +240| ObjectNode sig = (ObjectNode) wrapped.get("audit").get("behavior_signature"); +241| sig.remove("Z"); +242| ValidationResult result = adapter.validate(wrapped); +243| assertFalse(result.isValid()); +244| } +245| +246| @Test +247| @DisplayName("validate warns on unknown pattern") +248| void unknownPattern() { +249| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +250| ((ObjectNode) wrapped.get("audit")).put("behavior_pattern", "MODE-Unknown"); +251| ValidationResult result = adapter.validate(wrapped); +252| assertTrue(result.getWarnings().stream().anyMatch(w -> w.contains("Unknown behavior pattern"))); +253| } +254| +255| @Test +256| @DisplayName("validate warns on unknown color") +257| void unknownColor() { +258| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +259| ((ObjectNode) wrapped.get("audit")).put("color", "purple"); +260| ValidationResult result = adapter.validate(wrapped); +261| assertTrue(result.getWarnings().stream().anyMatch(w -> w.contains("Unknown audit color"))); +262| } +263| +264| @Test +265| @DisplayName("validate warns on suspicious payload hash") +266| void suspiciousPayloadHash() { +267| ObjectNode wrapped = adapter.wrap(mapOf("test", true), "test", "P04"); +268| ((ObjectNode) wrapped.get("audit")).put("payload_hash", "xyz"); +269| ValidationResult result = adapter.validate(wrapped); +270| assertTrue(result.getWarnings().stream().anyMatch(w -> w.contains("Suspicious payload_hash"))); +271| } +272| +273| @Test +274| @DisplayName("quickValidate returns false for non-JsonNode input") +275| void quickValidateNonObject() { +276| assertFalse(Validator.quickValidate(MAPPER.createObjectNode())); +277| } +278| +279| // --- ValidationResult tests --- +280| +281| @Test +282| @DisplayName("ValidationResult valid state") +283| void validationResultValid() { +284| ValidationResult r = new ValidationResult(true, null, null, "✅ VALID"); +285| assertTrue(r.isValid()); +286| assertTrue(r.getErrors().isEmpty()); +287| assertTrue(r.getWarnings().isEmpty()); +288| assertEquals("✅ VALID", r.getSummary()); +289| } +290| +291| @Test +292| @DisplayName("ValidationResult invalid state") +293| void validationResultInvalid() { +294| ValidationResult r = new ValidationResult(false, +295| java.util.Arrays.asList("error1"), null, "❌ INVALID"); +296| assertFalse(r.isValid()); +297| assertEquals(1, r.getErrors().size()); +298| assertTrue(r.getWarnings().isEmpty()); +299| } +300| +301| @Test +302| @DisplayName("ValidationResult has immutable lists") +303| void validationResultImmutability() { +304| ValidationResult r = new ValidationResult(true, +305| new java.util.ArrayList<>(java.util.Arrays.asList("e1")), +306| new java.util.ArrayList<>(java.util.Arrays.asList("w1")), +307| "summary"); +308| assertThrows(UnsupportedOperationException.class, () -> r.getErrors().add("e2")); +309| assertThrows(UnsupportedOperationException.class, () -> r.getWarnings().add("w2")); +310| } +311| +312| @Test +313| @DisplayName("ValidationResult equals and hashCode") +314| void validationResultEquals() { +315| ValidationResult r1 = new ValidationResult(true, null, null, "ok"); +316| ValidationResult r2 = new ValidationResult(true, null, null, "ok"); +317| assertEquals(r1, r2); +318| assertEquals(r1.hashCode(), r2.hashCode()); +319| } +320| +321| @Test +322| @DisplayName("ValidationResult toString") +323| void validationResultToString() { +324| ValidationResult r = new ValidationResult(true, null, null, "ok"); +325| String s = r.toString(); +326| assertTrue(s.contains("valid=true")); +327| assertTrue(s.contains("summary='ok'")); +328| } +329| +330| // --- Helper --- +331| +332| private static Map mapOf(Object... entries) { +333| Map map = new java.util.LinkedHashMap<>(); +334| for (int i = 0; i < entries.length; i += 2) { +335| map.put((String) entries[i], entries[i + 1]); +336| } +337| return map; +338| } +339|} \ No newline at end of file