@o3co/ts.hocon 0.1.0

package/tests/lightbend/testdata/test04.conf

@@ -0,0 +1,305 @@
+# This is an unmodified akka-reference.conf, except for this
+# comment and quoting one key that contained slashes.
+# Note: the outer akka{} would not be used in the usual setup
+# with this config lib.
+
+##############################
+# Akka Reference Config File #
+##############################
+
+# This the reference config file has all the default settings.
+# All these could be removed with no visible effect.
+# Modify as needed.
+# This file is imported in the 'akka.conf' file. Make your edits/overrides there.
+
+akka {
+  version = "2.0-SNAPSHOT" # Akka version, checked against the runtime version of Akka.
+
+  enabled-modules = []     # Comma separated list of the enabled modules. Options: ["cluster", "camel", "http"]
+
+  time-unit = "seconds"    # Time unit for all timeout properties throughout the config
+
+  event-handlers = ["akka.event.Logging$DefaultLogger"] # Event handlers to register at boot time (Logging$DefaultLogger logs to STDOUT)
+  loglevel        = "WARNING"                           # Options: ERROR, WARNING, INFO, DEBUG
+                                                        # this level is used by the configured loggers (see "event-handlers") as soon
+                                                        # as they have been started; before that, see "stdout-loglevel"
+  stdout-loglevel = "WARNING"                           # Loglevel for the very basic logger activated during AkkaApplication startup
+
+  event-handler-dispatcher {
+      type = "Dispatcher"              # Must be one of the following
+                                       # Dispatcher, (BalancingDispatcher, only valid when all actors using it are of the same type),
+                                       # A FQCN to a class inheriting MessageDispatcherConfigurator with a no-arg visible constructor
+      name = "EventHandlerDispatcher"  # Optional, will be a generated UUID if omitted
+      keep-alive-time = 60             # Keep alive time for threads
+      core-pool-size = 1               # No of core threads
+      max-pool-size  = 8               # Max no of threads
+      executor-bounds = -1             # Makes the Executor bounded, -1 is unbounded
+      task-queue-size = -1             # Specifies the bounded capacity of the task queue (< 1 == unbounded)
+      task-queue-type = "linked"       # Specifies which type of task queue will be used, can be "array" or "linked" (default)
+      allow-core-timeout = on          # Allow core threads to time out
+      rejection-policy = "caller-runs" # abort, caller-runs, discard-oldest, discard
+      throughput = 5                   # Throughput for Dispatcher, set to 1 for complete fairness
+      throughput-deadline-time = -1    # Throughput deadline for Dispatcher, set to 0 or negative for no deadline
+      mailbox-capacity = -1            # If negative (or zero) then an unbounded mailbox is used (default)
+                                       # If positive then a bounded mailbox is used and the capacity is set using the property
+                                       # NOTE: setting a mailbox to 'blocking' can be a bit dangerous, could lead to deadlock, use with care
+                                       # The following are only used for Dispatcher and only if mailbox-capacity > 0
+      mailbox-push-timeout-time = 10   # Specifies the timeout to add a new message to a mailbox that is full - negative number means infinite timeout
+                                       #       (in unit defined by the time-unit property)
+    }
+
+  # These boot classes are loaded (and created) automatically when the Akka Microkernel boots up
+  #     Can be used to bootstrap your application(s)
+  #     Should be the FQN (Fully Qualified Name) of the boot class which needs to have a default constructor
+  # boot = ["sample.camel.Boot",
+  #         "sample.rest.java.Boot",
+  #         "sample.rest.scala.Boot",
+  #         "sample.security.Boot"]
+  boot = []
+
+  actor {
+    timeout = 5                     # Default timeout for Future based invocations
+                                    #    - Actor:        ask && ?
+                                    #    - UntypedActor: ask
+                                    #    - TypedActor:   methods with non-void return type
+    serialize-messages = off        # Does a deep clone of (non-primitive) messages to ensure immutability
+    throughput = 5                  # Default throughput for all Dispatcher, set to 1 for complete fairness
+    throughput-deadline-time = -1   # Default throughput deadline for all Dispatcher, set to 0 or negative for no deadline
+    dispatcher-shutdown-timeout = 1 # Using the akka.time-unit, how long dispatchers by default will wait for new actors until they shut down
+
+    deployment {
+
+      "/app/service-ping" {                                               # deployment id pattern
+
+        router = "round-robin"                                          # routing (load-balance) scheme to use
+                                                                        #     available: "direct", "round-robin", "random", "scatter-gather"
+                                                                        #                "least-cpu", "least-ram", "least-messages"
+                                                                        #     or:        fully qualified class name of the router class
+                                                                        #     default is "direct";
+                                                                        #     if 'replication' is used then the only available router is "direct"
+
+        nr-of-instances = 3                                             # number of actor instances in the cluster
+                                                                        #     available: positive integer (1-N) or the string "auto" for auto-scaling
+                                                                        #     default is '1'
+                                                                        #     if the "direct" router is used then this element is ignored (always '1')
+
+        #create-as {
+        #  class = "com.biz.app.MyActor"                                # FIXME document 'create-as'
+        #}
+
+        remote {
+          nodes = ["wallace:2552", "gromit:2552"]                       # A list of hostnames and ports for instantiating the remote actor instances
+                                                                        #     The format should be on "hostname:port", where:
+                                                                        #         - hostname can be either hostname or IP address the remote actor should connect to
+                                                                        #         - port should be the port for the remote server on the other node
+        }
+
+        #cluster {                                                      # defines the actor as a clustered actor
+                                                                        #     default (if omitted) is local non-clustered actor
+
+        #  preferred-nodes = ["node:node1"]                             # a list of preferred nodes for instantiating the actor instances on
+                                                                        #     defined as node name
+                                                                        #     available: "node:<node name>"
+
+
+        #  replication {                                                # use replication or not? only makes sense for a stateful actor
+
+            # FIXME should we have this config option here? If so, implement it all through.
+        #    serialize-mailbox = off                                    # should the actor mailbox be part of the serialized snapshot?
+                                                                        #     default is 'off'
+
+        #    storage = "transaction-log"                                # storage model for replication
+                                                                        #     available: "transaction-log" and "data-grid"
+                                                                        #     default is "transaction-log"
+
+        #    strategy = "write-through"                                 # guaranteees for replication
+                                                                        #     available: "write-through" and "write-behind"
+                                                                        #     default is "write-through"
+
+        #  }
+        #}
+      }
+    }
+
+    default-dispatcher {
+      type = "Dispatcher"              # Must be one of the following
+                                       # Dispatcher, (BalancingDispatcher, only valid when all actors using it are of the same type),
+                                       # A FQCN to a class inheriting MessageDispatcherConfigurator with a no-arg visible constructor
+      name = "MyDispatcher"            # Optional, will be a generated UUID if omitted
+      keep-alive-time = 60             # Keep alive time for threads
+      core-pool-size-factor = 8.0      # No of core threads ... ceil(available processors * factor)
+      max-pool-size-factor  = 8.0      # Max no of threads ... ceil(available processors * factor)
+      executor-bounds = -1             # Makes the Executor bounded, -1 is unbounded
+      task-queue-size = -1             # Specifies the bounded capacity of the task queue (< 1 == unbounded)
+      task-queue-type = "linked"       # Specifies which type of task queue will be used, can be "array" or "linked" (default)
+      allow-core-timeout = on          # Allow core threads to time out
+      rejection-policy = "caller-runs" # abort, caller-runs, discard-oldest, discard
+      throughput = 5                   # Throughput for Dispatcher, set to 1 for complete fairness
+      throughput-deadline-time = -1    # Throughput deadline for Dispatcher, set to 0 or negative for no deadline
+      mailbox-capacity = -1            # If negative (or zero) then an unbounded mailbox is used (default)
+                                       # If positive then a bounded mailbox is used and the capacity is set using the property
+                                       # NOTE: setting a mailbox to 'blocking' can be a bit dangerous, could lead to deadlock, use with care
+                                       # The following are only used for Dispatcher and only if mailbox-capacity > 0
+      mailbox-push-timeout-time = 10   # Specifies the timeout to add a new message to a mailbox that is full - negative number means infinite timeout
+                                       #       (in unit defined by the time-unit property)
+    }
+
+    debug {
+      receive = off     # enable function of Actor.loggable(), which is to log any received message at DEBUG level
+      autoreceive = off # enable DEBUG logging of all AutoReceiveMessages (Kill, PoisonPill and the like)
+      lifecycle = off   # enable DEBUG logging of actor lifecycle changes
+    }
+
+    mailbox {
+
+      file-based {
+        directory-path = "./_mb"
+        max-items = 2147483647
+        max-size = 2147483647
+        max-items = 2147483647
+        max-age = 0
+        max-journal-size = 16777216 # 16 * 1024 * 1024
+        max-memory-size = 134217728 # 128 * 1024 * 1024
+        max-journal-overflow = 10
+        max-journal-size-absolute = 9223372036854775807
+        discard-old-when-full = on
+        keep-journal = on
+        sync-journal = off
+      }
+
+      redis {
+        hostname = "127.0.0.1"
+        port = 6379
+      }
+
+      mongodb {
+        # Any specified collection name will be used as a prefix for collections that use durable mongo mailboxes
+        uri = "mongodb://localhost/akka.mailbox" # Follow Mongo URI Spec - https://docs.mongodb.com/manual/reference/connection-string/
+
+        # Configurable timeouts for certain ops
+        timeout {
+          read = 3000 # number of milliseconds to wait for a read to succeed before timing out the future
+          write = 3000 # number of milliseconds to wait for a write to succeed before timing out the future
+        }
+      }
+
+      zookeeper {
+        server-addresses = "localhost:2181"
+        session-timeout = 60
+        connection-timeout = 60
+        blocking-queue = on
+      }
+
+      beanstalk {
+        hostname = "127.0.0.1"
+        port = 11300
+        reconnect-window = 5
+        message-submit-delay = 0
+        message-submit-timeout = 5
+        message-time-to-live = 120
+      }
+    }
+
+    # Entries for pluggable serializers and their bindings. If a binding for a specific class is not found,
+    # then the default serializer (Java serialization) is used.
+    #
+    # serializers {
+    #   java = "akka.serialization.JavaSerializer"
+    #   proto = "akka.testing.ProtobufSerializer"
+    #   sjson = "akka.testing.SJSONSerializer"
+    #   default = "akka.serialization.JavaSerializer"
+    # }
+
+    # serialization-bindings {
+    #   java = ["akka.serialization.SerializeSpec$Address",
+    #           "akka.serialization.MyJavaSerializableActor",
+    #           "akka.serialization.MyStatelessActorWithMessagesInMailbox",
+    #           "akka.serialization.MyActorWithProtobufMessagesInMailbox"]
+    #   sjson = ["akka.serialization.SerializeSpec$Person"]
+    #   proto = ["com.google.protobuf.Message",
+    #            "akka.actor.ProtobufProtocol$MyMessage"]
+    # }
+  }
+
+  remote {
+    # FIXME rename to transport
+    layer = "akka.cluster.netty.NettyRemoteSupport"
+
+    secure-cookie = ""                            # Generate your own with '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh'
+                                                  #     or using 'akka.util.Crypt.generateSecureCookie'
+
+    remote-daemon-ack-timeout = 30                # Timeout for ACK of cluster operations, lik checking actor out etc.
+
+    use-passive-connections = on                  # Reuse inbound connections for outbound messages
+
+    failure-detector {                            # accrual failure detection config
+      threshold = 8                               # defines the failure detector threshold
+                                                  #     A low threshold is prone to generate many wrong suspicions but ensures a
+                                                  #     quick detection in the event of a real crash. Conversely, a high threshold
+                                                  #     generates fewer mistakes but needs more time to detect actual crashes
+      max-sample-size = 1000
+    }
+
+    server {
+      port = 2552                                 # The default remote server port clients should connect to. Default is 2552 (AKKA)
+      message-frame-size = 1048576                # Increase this if you want to be able to send messages with large payloads
+      connection-timeout = 120                    # Length in time-unit
+      require-cookie = off                        # Should the remote server require that it peers share the same secure-cookie (defined in the 'remote' section)?
+      untrusted-mode = off                        # Enable untrusted mode for full security of server managed actors, allows untrusted clients to connect.
+      backlog = 4096                              # Sets the size of the connection backlog
+    }
+
+    client {
+      buffering {
+        retry-message-send-on-failure = false     # Should message buffering on remote client error be used (buffer flushed on successful reconnect)
+        capacity = -1                             # If negative (or zero) then an unbounded mailbox is used (default)
+                                                  #     If positive then a bounded mailbox is used and the capacity is set using the property
+      }
+      reconnect-delay = 5
+      read-timeout = 3600
+      message-frame-size = 1048576
+      reap-futures-delay = 5
+      reconnection-time-window = 600              # Maximum time window that a client should try to reconnect for
+    }
+  }
+
+  cluster {
+    name = "test-cluster"
+    zookeeper-server-addresses = "localhost:2181" # comma-separated list of '<hostname>:<port>' elements
+    max-time-to-wait-until-connected = 30
+    session-timeout = 60
+    connection-timeout = 60
+    include-ref-node-in-replica-set = on          # Can a replica be instantiated on the same node as the cluster reference to the actor
+                                                  #     Default: on
+    log-directory = "_akka_cluster"               # Where ZooKeeper should store the logs and data files
+
+    replication {
+      digest-type = "MAC"                         # Options: CRC32 (cheap & unsafe), MAC (expensive & secure using password)
+      password = "secret"                         # FIXME: store open in file?
+      ensemble-size = 3
+      quorum-size = 2
+      snapshot-frequency = 1000                   # The number of messages that should be logged between every actor snapshot
+      timeout = 30                                # Timeout for asyncronous (write-behind) operations
+    }
+  }
+
+  stm {
+    fair             = on     # Should global transactions be fair or non-fair (non fair yield better performance)
+    max-retries      = 1000
+    timeout          = 5      # Default timeout for blocking transactions and transaction set (in unit defined by
+                              #     the time-unit property)
+    write-skew       = true
+    blocking-allowed = false
+    interruptible    = false
+    speculative      = true
+    quick-release    = true
+    propagation      = "requires"
+    trace-level      = "none"
+  }
+
+  test {
+    timefactor = "1.0"        # factor by which to scale timeouts during tests, e.g. to account for shared build system load
+    filter-leeway = 3         # time-units EventFilter.intercept waits after the block is finished until all required messages are received
+    single-expect-default = 3 # time-units to wait in expectMsg and friends outside of within() block by default
+  }
+}

package/tests/lightbend/testdata/test05.conf

@@ -0,0 +1,154 @@
+# This is the main configuration file for the application.
+# ~~~~~
+application.name=Yet Another Blog Engine
+
+# Configuration of the blog engine
+# ~~~~~
+blog.title=Yet another blog
+blog.baseline=We will write about nothing
+
+# Application mode
+# ~~~~~
+# Set to dev to enable instant reloading and other development help.
+# Otherwise set to prod.
+application.mode=dev
+%prod.application.mode=prod
+
+# Secret key
+# ~~~~~
+# The secret key is used to secure cryptographics functions
+# If you deploy your application to several instances be sure to use the same key !
+application.secret=s1kwayg211q9v4387pvarbmyqnht7hrl54d34lsz0yh9btb117br293a25trz31o
+
+# Additional modules
+# ~~~~~
+# A module is another play! application. Add a line for each module you want
+# to add to your application. Modules path are either absolutes or relative to
+# the application root.
+
+# Import the crud module
+module.crud=${?play.path}/modules/crud
+
+# Import the secure module
+module.secure=${?play.path}/modules/secure
+
+# Import the cobertura module in test mode
+#%test.module.cobertura=${play.path}/modules/cobertura
+
+# i18n
+# ~~~~~
+# Define locales used by your application.
+# You can then place localized messages in conf/messages.{locale} files
+# application.langs=fr,en,ja
+
+# Server configuration
+# ~~~~~
+# If you need to change the HTTP port, uncomment this (default is set to 9000)
+# http.port=9000
+#
+# By default the server listen for HTTP on the wilcard address.
+# You can restrict this.
+# http.address=127.0.0.1
+
+# Session configuration
+# ~~~~~~~~~~~~~~~~~~~~~~
+# By default, session will be written to the transient PLAY_SESSION cookie.
+# application.session.cookie=PLAY
+# application.session.maxAge=1h
+
+# JPDA configuration
+# ~~~~~
+# Define which port is used by JPDA when application is in debug mode (default is set to 8000)
+# jpda.port=8000
+
+# Log level
+# ~~~~~
+# Specify log level for your application.
+# If you want a very customized log, create a log4j.properties file in the conf directory
+application.log=INFO
+
+# Database configuration
+# ~~~~~ 
+# Enable a database engine if needed.
+#
+# To quickly set up a development database, use either:
+#   - mem : for a transient in memory database (H2 in memory)
+#   - fs  : for a simple file written database (H2 file stored)
+db=mem
+#
+# To connect to a local MySQL5 database, use:
+# db=mysql:user:pwd@database_name
+#
+# If you need a full JDBC configuration use the following :
+# db.url=jdbc:postgresql:database_name
+# db.driver=org.postgresql.Driver
+# db.user=root
+# db.pass=secret
+#
+# Connections pool configuration :
+# db.pool.timeout=1000
+# db.pool.maxSize=30
+# db.pool.minSize=10
+#
+# If you want to reuse an existing Datasource from your application server, use:
+# db=java:/comp/env/jdbc/myDatasource
+
+# JPA Configuration (Hibernate)
+# ~~~~~
+#
+# Specify the custom JPA dialect to use here (default to guess):
+# jpa.dialect=org.hibernate.dialect.PostgreSQLDialect
+#
+# Specify the ddl generation pattern to use (default to update, set to none to disable it):
+jpa.ddl=update
+#
+# Debug SQL statements (logged using DEBUG level):
+# jpa.debugSQL=true
+#
+# You can even specify additional hibernate properties here:
+# hibernate.use_sql_comments=true
+# ...
+
+# Memcached configuration
+# ~~~~~ 
+# Enable memcached if needed. Otherwise a local cache is used.
+# memcached=enabled
+#
+# Specify memcached host (default to 127.0.0.1:11211)
+# memcached.host=127.0.0.1:11211
+#
+# Or you can specify multiple host to build a distributed cache
+# memcached.1.host=127.0.0.1:11211
+# memcached.2.host=127.0.0.1:11212
+
+# Mail configuration
+# ~~~~~ 
+# Default is to use a mock Mailer
+mail.smtp=mock
+
+# Or, specify mail host configuration
+# mail.smtp.host=127.0.0.1
+# mail.smtp.user=admin
+# mail.smtp.pass=
+# mail.smtp.channel=ssl
+
+# Execution pool
+# ~~~~~
+# Default to 1 thread in DEV mode or nb processors + 1 threads in PROD mode.
+# Try to keep a low as possible. 1 thread will serialize all requests (very usefull for debugging purpose)
+# play.pool=3
+
+# Open file from errors pages
+# ~~~~~
+# If your text editor supports to open files using URL, Play! will link
+# error pages to files dynamically
+#
+# Example, for textmate:
+# play.editor=txmt://open?url=file://%s&line=%s
+
+# Testing. Set up a custom configuration for test mode
+# ~~~~~
+%test.application.mode=dev
+%test.db=mem
+%test.jpa.ddl=create-drop
+%test.mail.smtp=mock

package/tests/lightbend/testdata/test06.conf

@@ -0,0 +1,14 @@
+## This file tests ConfigDelayedMerge and ConfigDelayedMergeObject
+
+a=1
+b=2
+c=3
+d={ "foo" : "bar" }
+
+# merge some x's
+x=${a}
+x=${b}
+
+# merge some y's where we know one is an object
+y=${d}
+y={ "hello" : "world", "foo" : 10 }

package/tests/lightbend/testdata/test07.conf

@@ -0,0 +1,4 @@
+# This file tests including a classpath resource when
+# loading something as a file or as a resource
+
+include "test-lib.conf"

package/tests/lightbend/testdata/test08.conf

@@ -0,0 +1,6 @@
+# This file tests including a classpath resource when
+# loading something as a file or as a resource.
+# It specifies the classpath resource with a "/" in front,
+# while test07 specifies it "relative"
+
+include "/test-lib.conf"

package/tests/lightbend/testdata/test09.conf

@@ -0,0 +1,17 @@
+// This file is testing ConfigDelayedMergeObject and ConfigDelayedMerge
+
+x={ q : 10 }
+y=5
+
+a=1
+a.q.r.s=${b}
+a=${y}
+a=${x}
+a={ c : 3 }
+
+b=${x}
+b=${y}
+
+// nesting ConfigDelayed inside another one
+c=${x}
+c={ d : 600, e : ${a}, f : ${b} }

package/tests/lightbend/testdata/test10.conf

@@ -0,0 +1,11 @@
+// this checks relativizing ConfigDelayedMerge, ConfigDelayedMergeObject
+
+foo {
+  include "test09.conf"
+}
+
+bar {
+  nested {
+    include "test09.conf"
+  }
+}

package/tests/lightbend/testdata/test11.conf

@@ -0,0 +1,7 @@
+// this checks quoting of strings that could be numbers, when we render
+
+"10" = "42"
+"-10" = "-42"
+foo-bar = bar-baz
+"---" = "------"
+a- = b-

package/tests/lightbend/testdata/test12.conf

@@ -0,0 +1,43 @@
+// this checks sorting map keys, where keys that look like numbers are treated differently
+// specifically tests very long numbers which fit neither in an Integer nor in a Long
+
+"10" = "42"
+sth = 42
+"1" = "42"
+"12" = "42"
+"123" = "42"
+"1234" = "42"
+"12345" = "42"
+"123456" = "42"
+"1234567" = "42"
+"12345678" = "42"
+"123456789" = "42"
+"1234567890" = "42"
+"12345678901" = "42"
+"123456789012" = "42"
+"1234567890123" = "42"
+"12345678901234" = "42"
+"123456789012345" = "42"
+"1234567890123456" = "42"
+"12345678901234567" = "42"
+"123456789012345678" = "42"
+"1234567890123456789" = "42"
+"12345678901234567891" = "42"
+"123456789012345678912" = "42"
+"1234567890123456789123" = "42"
+"12345678901234567891234" = "42"
+"123456789012345678912345" = "42"
+"1234567890123456789123456" = "42"
+"12345678901234567891234567" = "42"
+"123456789012345678912345678" = "42"
+"1234567890123456789123456789" = "42"
+"12345678901234567891234567890" = "42"
+"123456789012345678912345678901" = "42"
+"1234567890123456789123456789012" = "42"
+"12345678901234567891234567890123" = "42"
+"123456789012345678912345678901234" = "42"
+"1234567890123456789123456789012345" = "42"
+"12345678901234567891234567890123456" = "42"
+"123456789012345678912345678901234567" = "42"
+"1234567890123456789123456789012345678" = "42"
+"12345678901234567891234567890123456789" = "42"

package/tests/lightbend/testdata/test13-application-override-substitutions.conf

@@ -0,0 +1 @@
+b = "overridden"

package/tests/lightbend/testdata/test13-reference-bad-substitutions.conf

@@ -0,0 +1 @@
+a = ${b}

package/tests/lightbend/testdata/test13-reference-with-substitutions.conf

@@ -0,0 +1,2 @@
+a = ${b}
+b = "b"

package/tests/lightbend/testdata/validate-invalid.conf

@@ -0,0 +1,30 @@
+string1="a string"
+string2=107
+string3={ a : b }
+string4=[]
+int1=203
+int2="foo"
+int3={ q : s }
+float1="the string"
+float2=false
+float3=[ 4, 5, 6 ]
+bool1=709
+bool2="string!"
+bool3={}
+null1=10000
+null2="hello world"
+null3=true
+object1={ z : s }
+object2=[]
+object3=12345
+array1=[1,2,"foo"]
+array2=[7,8,9]
+array3=[{ n : m }, 10]
+array4=[42, 43]
+array5=64
+emptyArray1=[1,2,3]
+emptyArray2=["a","b","c"]
+
+a.b.c.d.e.f.g = 100
+a.b.c.d.e.f.h = "foo"
+a.b.c.d.e.f.i = []

package/tests/lightbend/testdata/validate-reference.conf

@@ -0,0 +1,32 @@
+string1="foo"
+string2="bar"
+string3="baz"
+string4="hello"
+int1=10
+int2=11
+int3=12
+float1=3.14
+float2=3.2
+float3=3.3
+bool1=true
+bool2=false
+bool3=true
+null1=null
+null2=null
+null3=null
+object1={ a : b }
+object2={ c : d }
+object3={ e : f }
+array1=[1,2,3]
+array2=[a,b,c]
+array3=[true, true, false]
+array4=[{}, {}]
+array5=[]
+emptyArray1=[]
+emptyArray2=[]
+willBeMissing=90009
+
+a.b.c.d.e.f.g = true
+a.b.c.d.e.f.h = true
+a.b.c.d.e.f.i = true
+a.b.c.d.e.f.j = true