Initial commit. This is beginning to work.

.gitignore

@@ -0,0 +1,20 @@
+/target
+/classes
+/checkouts
+profiles.clj
+pom.xml
+pom.xml.asc
+*~
+*.jar
+*.class
+/.lein-*
+/.nrepl-port
+/.prepl-port
+.hgignore
+.hg/
+.clj-kondo/
+.lsp/
+.portal/
+.calva/output-window/output.calva-repl
+
+dengine.code-workspace

CHANGELOG.md

@@ -0,0 +1,24 @@
+# Change Log
+All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
+
+## [Unreleased]
+### Changed
+- Add a new arity to `make-widget-async` to provide a different widget shape.
+
+## [0.1.1] - 2025-08-03
+### Changed
+- Documentation on how to make the widgets.
+
+### Removed
+- `make-widget-sync` - we're all async, all the time.
+
+### Fixed
+- Fixed widget maker to keep working when daylight savings switches over.
+
+## 0.1.0 - 2025-08-03
+### Added
+- Files from the new template.
+- Widget maker public API - `make-widget-sync`.
+
+[Unreleased]: https://sourcehost.site/your-name/dengine/compare/0.1.1...HEAD
+[0.1.1]: https://sourcehost.site/your-name/dengine/compare/0.1.0...0.1.1

LICENSE

@@ -0,0 +1,280 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: GNU General Public
+License as published by the Free Software Foundation, either version 2
+of the License, or (at your option) any later version, with the GNU
+Classpath Exception which is available at
+https://www.gnu.org/software/classpath/license.html."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.

doc/intro.md

@@ -0,0 +1,3 @@
+# Introduction to dengine
+
+TODO: write [great documentation](http://jacobian.org/writing/what-to-write/)

project.clj

@@ -0,0 +1,8 @@
+(defproject dengine "0.1.0-SNAPSHOT"
+  :description "FIXME: write description"
+  :url "http://example.com/FIXME"
+  :license {:name "EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0"
+            :url "https://www.eclipse.org/legal/epl-2.0/"}
+  :dependencies [[org.clojure/clojure "1.11.1"]
+                 [org.clojure/clojure "1.12.0"]]
+  :repl-options {:init-ns arboretum.dengine.core})

src/arboretum/dengine/case.clj

@@ -0,0 +1,10 @@
+(ns arboretum.dengine.case
+  (:require [arboretum.dengine.protocols :refer [Case]]))
+
+(defrecord CaseImpl [ id  name knowledge]
+  Case
+  (id [this] :foo);;(:id this))
+  (name [this] "foo") ;;(or (:name this) (clojure.core/name (:id this))))
+  (knowledge [this] (:knowledge this))
+  (is? [this feature-id] ((:knowledge this) feature-id))
+  )

src/arboretum/dengine/core.clj

@@ -0,0 +1,14 @@
+(ns arboretum.dengine.core
+  ;; (:require [arboretum.dengine.feature :refer [decide explain]]
+  ;;           [arboretum.dengine.protocols :refer [proposition]])
+  )
+
+(defn foo
+  "I don't do a whole lot."
+  [x]
+  (println x "Hello, World!"))
+
+;; (defn is? 
+;;   [feature case kb]
+;;   (let [evaluation (decide feature case kb)]
+;;     ((proposition feature) evaluation)))

src/arboretum/dengine/feature.clj

@@ -0,0 +1,35 @@
+(ns arboretum.dengine.feature
+  (:require [arboretum.dengine.kb :refer [!kb]]
+            [arboretum.dengine.protocols :refer [Case Feature Node]]
+            [arboretum.dengine.utils :refer [string->keyword]]
+            [clojure.spec.alpha :as spec]))
+
+(spec/def :arboretum.dengine.feature/name string?)
+
+(spec/def :arboretum.dengine.feature/default boolean?)
+
+(defn- dengine [this c]
+  (let [c' (if (satisfies? Case c) c (-> @!kb :cases c))]
+    (when (nil? c') (throw (ex-info "Unknown or invalid case"
+                                    {:case-identifier c})))
+    (if (:rootnode this)
+      (when-not (satisfies? Node (:rootnode this))
+        (throw (ex-info "Invalid DTree node"
+                        {:node (:rootnode this)
+                         :context this})))
+      (first
+       (filter boolean?
+               (map #(.evaluate % c)
+                    (-> this :rootnode :children)))))))
+
+(defrecord FeatureImpl [^String proposition ^boolean default rootnode]
+  Feature
+  (decide [this c] (let [v ((.id this) c)]
+                     (cond (boolean? v) v
+                           (:rootnode this) (dengine (:rootnode this) c)
+                           :else (:default this))))
+  (default [this] (:default this))
+  (id [this] (string->keyword (:proposition this)))
+  (rootnode [this] (:rootnode this))
+  (proposition [this] (:proposition this)))
+

src/arboretum/dengine/kb.clj

@@ -0,0 +1,44 @@
+(ns arboretum.dengine.kb
+  (:require
+   arboretum.dengine.case
+   [arboretum.dengine.protocols :refer [Case Feature Kb]]
+   [arboretum.dengine.utils :refer [string->keyword]]
+   [clojure.pprint :refer [pprint]])
+  (:import
+   [arboretum.dengine.case CaseImpl]))
+
+(defrecord KBImpl [cases features]
+  Kb
+  (cases [this] (:cases this))
+  (features [this] (:features this))
+  (get-case [this case-id] (-> this :cases case-id))
+  (get-feature [this feature-id] (-> this :features feature-id))
+  (is? [this case-or-id feature-or-id]
+    (let [c (if (satisfies? Case case-or-id) 
+              case-or-id (-> this :cases case-or-id))
+          f (if (satisfies? Feature feature-or-id) feature-or-id 
+                (-> this :features feature-or-id))]
+      (-> c (:id f)))))
+
+(def !kb
+  "The one instance of the knowledge base."
+  (atom (KBImpl. nil nil)))
+
+(defn add-case
+  "Add a case to the knowledge base with this `name`, and, if supplied, this `id`."
+  ([^String name]
+  (add-case name (string->keyword name (map :id (.cases @!kb)))))
+  ([^String name ^clojure.lang.Keyword id]
+   (let [c (CaseImpl. id name {})]
+    (swap! !kb update-in :cases conj c))))
+
+(defn persist [filepath] 
+  (let [p (if (empty? filepath) "kb.edn" filepath)]
+                                (spit p (with-out-str (pprint @!kb)))))
+(defn restore [filepath] 
+  (let [p (if (empty? filepath) "kb.edn" filepath)
+        kb (read-string (slurp p))]
+    (if (satisfies? Kb kb) (reset! !kb kb)
+        (throw (ex-info "Not a knowledge base?" {:filepath filepath
+                                                :kb kb
+                                                :type (type kb)})))))

src/arboretum/dengine/node.clj

@@ -0,0 +1,12 @@
+(ns arboretum.dengine.node
+  (:require [arboretum.dengine.protocols :refer [Node]]
+            [clojure.spec.alpha :as spec]))
+
+(defrecord NodeImpl [children ^Boolean colour feature ^String fragment]
+           Node
+  (children [this] "The children of this node" (:children this))
+  (colour ^Boolean [this] "The colour of this node" (:colour this))
+  (feature [this] "The feature at this node" (:feature this))
+  (fragment ^String [this] "The explanation fragment at this node")
+  (evaluate [this case-id] )
+  )

src/arboretum/dengine/protocols.clj

@@ -0,0 +1,70 @@
+(ns arboretum.dengine.protocols
+  (:require [clojure.spec.alpha :as spec]))
+
+;;(declare node?)
+
+;; Design problem here is that the structure of a feature optionally contains
+;; a node, and the structure of a node necessarily containt a feature; but two
+;; clojure namespaces cannot depend on one another.
+
+(defprotocol Case
+  "A case to be decided. It represents an object-in-the-world about
+    which knowledge may be held and enquiries may be made."
+  (id ^Keyword [this] "Returns the `:id` of this case.")
+  (name ^String [this] "Returns the name associated with this case")
+  (knowledge ^APersistentMap [this] "Returns a map whose keys are ids of features 
+                                     and whose values are the values of those 
+                                     features in this case.")
+  (is? ^Boolean [this feature-id] "Returns `true` if feature-id true of `this`,
+                                     `false` if it's definitely not true, and
+                                     `nil` if its truth value is unknown."))
+
+(defmacro case?
+  "Return `true` if this `obj` appears to be a valid case.
+   
+   **NOTE THAT** this does not verify that every key is the id of some feature
+   konwn to the knowledge base."
+  [obj]
+  `(satisfies? Case ~obj))
+
+(defprotocol Feature
+  "A feature has three essential elements: a proposition, a default value, and
+    a method of decision"
+  (decide ^Boolean [this case] "Returns the default value of my proposition for this `case`.
+                                
+                                `case` should be either an object which satisfies the `Case`
+                                protocol or else a keyword, in which case it should be the
+                                key of some case in the global `kb`.")
+  (default ^Boolean [this] "Returns the default value of my proposition")
+  (id ^Keyword [this] "Returns a keywordised representation of the proposition of this feature")
+  (proposition ^String [this] "Returns the proposition associated with this feature")
+  (rootnode [this] "Returns the root node of the dtree for this feature, if one exists, else `nil`"))
+
+(defmacro feature?
+  [obj]
+  `(satisfies? Feature ~obj))
+
+(defprotocol Kb
+  ;; "The knowledge base"
+  (get-case ^APersistentMap [this ^Keyword id] 
+    "Return the case with this `id` from among my cases,
+     if present, else `nil`")
+  (cases ^APersistentMap [this] 
+    "All cases known in this knowledge base, keyed by `:id`")
+  (get-feature ^APersistentMap [this id-or-prop] 
+    "Return the feature with this `id` from among my features,
+     if present, else `nil`")
+  (features ^APersistentMap [this] 
+    "All features known in this knowledge base, keyed by `:proposition`")
+  (is? ^Boolean [this case-or-id feature-or-id] 
+    "Is the feature identified by `feature-or-id` true of the case identified 
+     by `case-or-id?"))
+
+(defprotocol Node
+  "A node in a DTree"
+  (children [this] "The children of this node")
+  (colour ^Boolean [this] "The colour of this node")
+  (feature [this] "The feature at this node")
+  (fragment ^String [this] "The explanation fragment at this node")
+  (evaluate [this case-id] "evaluate this node in the context of the case identified by `case-id`.")
+  (explain [this case-id] "return an explanation from this node or its children for the case identified by `case-id`"))

src/arboretum/dengine/utils.clj

@@ -0,0 +1,17 @@
+(ns arboretum.dengine.utils
+  (:require
+   [clojure.string :refer [lower-case replace]]) 
+  (:import
+   [clojure.lang PersistentHashSet]))
+
+(defn string->keyword 
+  "Produce a keyword based on this `s`. If `others` are supplied, the return
+   value will be different from any of those others."
+  ([^String s]
+  (let [x (replace 
+           (replace (lower-case s) #"[^]a-z0-9- ]" "")
+           #" " "-")]
+    (keyword (if (empty? x) (gensym) x))))
+  ([^String s ^PersistentHashSet others]
+   (let [c (string->keyword s)]
+     (if (others c) (keyword (gensym (name c))) c))))

test/dengine/feature_test.clj

@@ -0,0 +1,20 @@
+(ns dengine.feature-test
+   (:require [clojure.test :refer [deftest is testing]]
+            [arboretum.dengine.feature :refer :all])
+  (:import [arboretum.dengine.feature FeatureImpl]))
+
+(deftest feature-impl-test
+      (testing "Testing feature implementation"
+        (let [f (FeatureImpl. "Is entitled to Widow's Allowance" false nil)]
+          (let [expected :is-entitled-to-widows-allowance
+                actual (.id f)]
+            (is (= actual expected)))
+          (let [expected false
+                actual (.default f)]
+            (is (= actual expected)))
+          (let [expected false
+                actual (.decide f {})]
+            (is (= actual expected) "If we have no knoledge and no decision method, take the defualt."))
+          (let [expected false
+                actual (.decide f {:is-entitled-to-widows-benefit true})]
+            (is (= actual expected) "If we have knoledge, return it."))))) 

test/dengine/kb_test.clj

@@ -0,0 +1,26 @@
+(ns dengine.kb-test
+  (:require [clojure.test :refer [deftest is testing]]
+            arboretum.dengine.case
+            arboretum.dengine.feature
+            [arboretum.dengine.kb :refer :all])
+  (:import [arboretum.dengine.case CaseImpl]
+           [arboretum.dengine.feature FeatureImpl]
+           [arboretum.dengine.kb KBImpl]))
+
+(def testkb (KBImpl. [(CaseImpl. :case_1 "Mrs Nora Trellis" {:married true :divorced false})] 
+                     [(FeatureImpl. "is entitled to Widow's Benefit" false nil)]))
+
+(reset! !kb testkb)
+
+(deftest access-test
+  (testing "Accessing knowledge in the knowledge base"
+    (let [expected nil
+          actual (.is? testkb :case_1 :widowed)]
+      (is (= actual expected)))
+    (let [expected true
+          actual (.is? testkb :case_1 :married)]
+      (is (= actual expected)))
+    (let [expected false
+          actual (.is? testkb :case_1 :divorced)]
+      (is (= actual expected)))
+    ))

test/dengine/utils_test.clj

@@ -0,0 +1,16 @@
+(ns dengine.utils-test
+  (:require [clojure.test :refer [deftest is testing]]
+            [arboretum.dengine.utils :refer [string->keyword]]))
+
+
+(deftest string-to-keyword-test
+  (testing "string->keyword"
+    (let [s "Entitled to Widow's Benefit"
+          expected :entitled-to-widows-benefit
+          actual (string->keyword s)]
+      (is (= actual expected)))
+     (let [s "Entitled to Widow's Benefit"
+       expected :entitled-to-widows-benefit
+       actual (string->keyword s)]
+   (is (= actual expected)))
+   ))