# Copyright 2005-2008 Kevin Reid, under the terms of the MIT X license
# found at http://www.opensource.org/licenses/mit-license.html ................

import
  
  ? <import>
  # value: <import:*>
  
  ? def allOf := <import:org.erights.e.tools.collect.allOf>
  # value: <allOf>
  
  ? allOf([1, 2, 3], def _(x) :any {return x < 4})
  # value: true
  
  ? def eLoader := <import:org.erights.e.*>
  # value: <import:org.erights.e.*>
  
  ? eLoader["tools.collect.allOf"]
  # value: <allOf>
  
  ? def ["tools.collect.allOf" => a, 
  >      "elib.ref.makeProxy" => m] | _ := eLoader
  > [a, m]
  # value: [<allOf>, <makeProxy>]
  
  ? <import> :DeepFrozen
  # value: <import:*>
  
  ? <import>.fetch("org.erights.e.tools.collect.allOf", fn {throw("bang")})
  # value: <allOf>
  
  ? <import>.fetch("a.fqn.with.no.referent", fn {throw("bang")})
  # problem: bang
  
 DeepFrozen importing
 
  we're assuming that allOf can be used as an example of non-deep-frozen import '
  ? allOf == <import:org.erights.e.tools.collect.allOf>
  # value: false
  
  ? <elib:slot.makeBaseGuard> == <elib:slot.makeBaseGuard>
  # value: true

 Uncall/unget
 
  ? [<import>.optUncall(53)]
  # value: [null]

  ? [<import>.optUncall(<elang:evm.makeNounExpr>)]
  # value: [[<import:*>, "get", ["org.erights.e.elang.evm.makeNounExpr"]]]
  
  ? [<import>.optUnget(<elang:evm.makeNounExpr>)]
  # value: ["org.erights.e.elang.evm.makeNounExpr"]

  XXX uncall/unget by and of package loaders
  XXX uncall of all varieties of subloaders (vm-node is a bad general example)

 Uncall/unget on emakers
 
  ? [<import:org.cubik.cle.test.importUncall.ok> == <import:org.cubik.cle.test.importUncall.ok>,
  >  <import>.optUnget(<import:org.cubik.cle.test.importUncall.ok>)]
  # value: [true, "org.cubik.cle.test.importUncall.ok"]

  ? [<import:org.cubik.cle.test.importUncall.notUnique> == <import:org.cubik.cle.test.importUncall.notUnique>,
  >  <import>.optUnget(<import:org.cubik.cle.test.importUncall.notUnique>)]
  # value: [false, null]

  ? [<import:org.cubik.cle.test.importUncall.notRequested> == <import:org.cubik.cle.test.importUncall.notRequested>,
  >  <import>.optUnget(<import:org.cubik.cle.test.importUncall.notRequested>)]
  # value: [true, null]

  ? [<import:org.cubik.cle.test.importUncall.selfless> == <import:org.cubik.cle.test.importUncall.selfless>,
  >  <import>.optUnget(<import:org.cubik.cle.test.importUncall.selfless>)]
  # value: [true, null]

  ? [<import:org.cubik.cle.test.importUncall.askedEarly> == <import:org.cubik.cle.test.importUncall.askedEarly>,
  >  <import>.optUnget(<import:org.cubik.cle.test.importUncall.askedEarly>)]
  # value: [true, null]

emaker loading rebinds some nouns (as of this writing, trace[ln] and ExitViaHere), so check their guards. 

XXX it would be better to extract the environment and pass it out of the emaker, and test it here, but as we do not yet have either proper meta.getState() or &&noun, we can't do that.

  ? <import:org.cubik.cle.test.emakerEnvGuards>
  # value: "ok"

<elib>, <elang>

  ? <elib>
  # value: <import:org.erights.e.elib.*>

  ? <elang>
  # value: <import:org.erights.e.elang.*>

see ref.updoc for Ref

<type>

  ? <type>
  # value: <type:*>
  
  ? <type:org.erights.e.elib.serial.Uncaller>
  # value: Uncaller

<opaque>

  ? <opaque>
  # value: <opaque__uriGetter0>
            
  ? <opaque:foo>
  # value: <ref broken by problem: opaque:foo>
            
  ? <opaque>.optUncall(<import>)
  # value: [<opaque__uriGetter0>, "get", ["import:*"]]

<resource>

  ? <resource>
  # value: <resource__uriGetter>
  
  ? <resource:org/cubik/cle/makeIOScope.emaker>.getText().split("\n")[0]
  # value: "# Copyright 2005-2007 Kevin Reid, under the terms of the MIT X license"

safeScope
  
  ? safeScope["int"]
  # value: int
  
  ? safeScope.with("pi", 3.14159)["pi"]
  # value: 3.14159

Every binding in the safeScope exposes its value in its guard, since all the values are well-known.

  ? safeScope.bindings().fetch("false", throw).getGuard()
  # value: Same[<& false>]

  ? safeScope.bindings().fetch("int", throw).getGuard()
  # value: Same[<LazyEvalSlot>]
  
  ? safeScope.bindings().fetch("int", throw).getGuard().getAllowed()[]
  # value: int
  
Everything in the safeScope should be DeepFrozen, on general principles and because otherwise the magic lazy-eval-slots are incoherent; testing this.

  ? for `&@noun` => &thing in safeScope { 
  >    if (!DeepFrozen.isDeepFrozen(thing)) { println(`$noun ($thing) ought to be DeepFrozen`) }
  > }
  > print("ok")
  # stdout: near (near) ought to be DeepFrozen
  #         opaque__uriGetter (<opaque__uriGetter0>) ought to be DeepFrozen
  #         promiseAllFulfilled (<promiseAllFulfilled0>) ought to be DeepFrozen
  #         rcvr (rcvr) ought to be DeepFrozen
  #         rx__quasiParser (<makePerlMatchMaker>) ought to be DeepFrozen
  #         term__quasiParser (<term__quasiParser>) ought to be DeepFrozen
  #         ok
  
  XXX fix things until the above test produces no errors

XXX scope#get/1 with funny/nonexistent keys