Test_Build

Provides unit tests and examples for the Build lens.

Summary
Test_BuildProvides unit tests and examples for the Build lens.
GENERIC CONSTRUCTIONS
bracketsTest brackets
brackets
LIST CONSTRUCTIONS
list
list
list
opt_list
opt_list
LABEL OPERATIONS
xchg
xchg
xchgs
xchgs
SUBNODE CONSTRUCTIONS
key_value_line
key_value_line
key_value_line_comment
key_value_line_comment
key_value
key_value
key_ws_value
key_ws_value
flag
flag
flag_line
flag_line
BLOCK CONSTRUCTIONS
block_entryThe block entry used for testing
blockThe block used for testing
blockSimple test for block
blockSimple test for block with newlines
blockSimple test for block two indented entries
blockTest block with a comment
blockTest block with comments and newlines
blockTest defaults for blocks
named_blockThe named block used for testing
named_blockSimple test for named_block
logrotate_blockA minimalistic logrotate block
logrotate_block
COMBINATORICS
combine_twoA minimalistic combination lens
combine_twoShould parse ab
combine_twoShould parse ba
combine_twoShould not parse a
combine_twoShould not parse b
combine_twoShould not parse aa
combine_twoShould not parse bb
combine_two_optA minimalistic optional combination lens
combine_two_optShould parse ab
combine_two_optShould parse ba
combine_two_optShould parse a
combine_two_optShould parse b
combine_two_optShould not parse aa
combine_two_optShould not parse bb
combine_threeA minimalistic optional combination lens
combine_threeShould not parse ab
combine_threeShould not parse ba
combine_threeShould not parse a
combine_threeShould not parse b
combine_threeShould not parse aa
combine_threeShould not parse bbc
combine_threeShould parse abc
combine_threeShould parse cab
combine_three_optA minimalistic optional combination lens
combine_three_optShould parse ab
combine_three_optShould parse ba
combine_three_optShould parse a
combine_three_optShould parse b
combine_three_optShould not parse aa
combine_three_optShould not parse bbc
combine_three_optShould parse abc
combine_three_optShould parse cab

GENERIC CONSTRUCTIONS

brackets

let brackets = [ Build.brackets Sep.lbracket Sep.rbracket (key Rx.word) ]

Test brackets

brackets

test brackets get "(foo)" = { "foo" }

LIST CONSTRUCTIONS

list

let list = Build.list [ key Rx.word ] Sep.space

list

test list get "foo bar baz" = { "foo" } { "bar" } { "baz" }

list

test list get "foo" = *

opt_list

let opt_list = Build.opt_list [ key Rx.word ] Sep.space

opt_list

test opt_list get "foo bar baz" = { "foo" } { "bar" } { "baz" }

LABEL OPERATIONS

xchg

let xchg = [ Build.xchg Rx.space " " "space" ]

xchg

test xchg get " \t " = { "space" }

xchgs

let xchgs = [ Build.xchgs " " "space" ]

xchgs

test xchgs get " " = { "space" }

SUBNODE CONSTRUCTIONS

key_value_line

let key_value_line = Build.key_value_line Rx.word Sep.equal (store Rx.word)

key_value_line

test key_value_line get "foo=bar\n" = { "foo" = "bar" }

key_value_line_comment

let key_value_line_comment = Build.key_value_line_comment Rx.word Sep.equal (store Rx.word) Util.comment

key_value_line_comment

test key_value_line_comment get "foo=bar # comment\n" = { "foo" = "bar" { "#comment" = "comment" } }

key_value

let key_value = Build.key_value Rx.word Sep.equal (store Rx.word)

key_value

test key_value get "foo=bar" = { "foo" = "bar" }

key_ws_value

let key_ws_value = Build.key_ws_value Rx.word

key_ws_value

test key_ws_value get "foo bar\n" = { "foo" = "bar" }

flag

let flag = Build.flag Rx.word

flag

test flag get "foo" = { "foo" }

flag_line

let flag_line = Build.flag_line Rx.word

flag_line

test flag_line get "foo\n" = { "foo" }

BLOCK CONSTRUCTIONS

block_entry

let block_entry = Build.key_value "test" Sep.equal (store Rx.word)

The block entry used for testing

block

let block = Build.block block_entry

The block used for testing

block

test block get " {test=1}" = { "test" = "1" }

Simple test for block

block

test block get " {\n test=1\n}" = { "test" = "1" }

Simple test for block with newlines

block

test block get " {\n test=1 \n test=2 \n}" = { "test" = "1" } { "test" = "2" }

Simple test for block two indented entries

block

test block get " { # This is a comment\n}" = { "#comment" = "This is a comment" }

Test block with a comment

block

test block get " { # This is a comment\n# Another comment\n}" = { "#comment" = "This is a comment" } { "#comment" = "Another comment" }

Test block with comments and newlines

block

test block put " { test=1 }" after set "/#comment" "a comment"; rm "/

Test defaults for blocks

named_block

let named_block = Build.named_block "foo" block_entry

The named block used for testing

named_block

test named_block get "foo {test=1}\n" = { "foo" { "test" = "1" } }

Simple test for named_block

logrotate_block

let logrotate_block = let entry = [ key Rx.word ] in let filename = [ label "file" . store /\/[^,#= \n\t{}]+/ ] in let filename_sep = del /[ \t\n]+/ " " in let filenames = Build.opt_list filename filename_sep in [ label "rule" . filenames . Build.block entry ]

A minimalistic logrotate block

logrotate_block

test logrotate_block get "/var/log/wtmp\n/var/log/wtmp2\n{ missingok monthly }" = { "rule" { "file" = "/var/log/wtmp" } { "file" = "/var/log/wtmp2" } { "missingok" } { "monthly" } }

COMBINATORICS

combine_two

let combine_two = let entry (k:string) = [ key k ] in Build.combine_two (entry "a") (entry "b")

A minimalistic combination lens

combine_two

test combine_two get "ab" = { "a" } { "b" }

Should parse ab

combine_two

test combine_two get "ba" = { "b" } { "a" }

Should parse ba

combine_two

test combine_two get "a" = *

Should not parse a

combine_two

test combine_two get "b" = *

Should not parse b

combine_two

test combine_two get "aa" = *

Should not parse aa

combine_two

test combine_two get "bb" = *

Should not parse bb

combine_two_opt

let combine_two_opt = let entry (k:string) = [ key k ] in Build.combine_two_opt (entry "a") (entry "b")

A minimalistic optional combination lens

combine_two_opt

test combine_two_opt get "ab" = { "a" } { "b" }

Should parse ab

combine_two_opt

test combine_two_opt get "ba" = { "b" } { "a" }

Should parse ba

combine_two_opt

test combine_two_opt get "a" = { "a" }

Should parse a

combine_two_opt

test combine_two_opt get "b" = { "b" }

Should parse b

combine_two_opt

test combine_two_opt get "aa" = *

Should not parse aa

combine_two_opt

test combine_two_opt get "bb" = *

Should not parse bb

combine_three

let combine_three = let entry (k:string) = [ key k ] in Build.combine_three (entry "a") (entry "b") (entry "c")

A minimalistic optional combination lens

combine_three

test combine_three get "ab" = *

Should not parse ab

combine_three

test combine_three get "ba" = *

Should not parse ba

combine_three

test combine_three get "a" = *

Should not parse a

combine_three

test combine_three get "b" = *

Should not parse b

combine_three

test combine_three get "aa" = *

Should not parse aa

combine_three

test combine_three get "bbc" = *

Should not parse bbc

combine_three

test combine_three get "abc" = { "a" } { "b" } { "c" }

Should parse abc

combine_three

test combine_three get "cab" = { "c" } { "a" } { "b" }

Should parse cab

combine_three_opt

let combine_three_opt = let entry (k:string) = [ key k ] in Build.combine_three_opt (entry "a") (entry "b") (entry "c")

A minimalistic optional combination lens

combine_three_opt

test combine_three_opt get "ab" = { "a" } { "b" }

Should parse ab

combine_three_opt

test combine_three_opt get "ba" = { "b" } { "a" }

Should parse ba

combine_three_opt

test combine_three_opt get "a" = { "a" }

Should parse a

combine_three_opt

test combine_three_opt get "b" = { "b" }

Should parse b

combine_three_opt

test combine_three_opt get "aa" = *

Should not parse aa

combine_three_opt

test combine_three_opt get "bbc" = *

Should not parse bbc

combine_three_opt

test combine_three_opt get "abc" = { "a" } { "b" } { "c" }

Should parse abc

combine_three_opt

test combine_three_opt get "cab" = { "c" } { "a" } { "b" }

Should parse cab

Generic functions to build lenses
let brackets = [ Build.brackets Sep.lbracket Sep.rbracket (key Rx.word) ]
Test brackets
let list = Build.list [ key Rx.word ] Sep.space
let opt_list = Build.opt_list [ key Rx.word ] Sep.space
let xchg = [ Build.xchg Rx.space " " "space" ]
let xchgs = [ Build.xchgs " " "space" ]
let key_value_line = Build.key_value_line Rx.word Sep.equal (store Rx.word)
let key_value_line_comment = Build.key_value_line_comment Rx.word Sep.equal (store Rx.word) Util.comment
let key_value = Build.key_value Rx.word Sep.equal (store Rx.word)
let key_ws_value = Build.key_ws_value Rx.word
let flag = Build.flag Rx.word
let flag_line = Build.flag_line Rx.word
let block_entry = Build.key_value "test" Sep.equal (store Rx.word)
The block entry used for testing
let block = Build.block block_entry
The block used for testing
let named_block = Build.named_block "foo" block_entry
The named block used for testing
let logrotate_block = let entry = [ key Rx.word ] in let filename = [ label "file" . store /\/[^,#= \n\t{}]+/ ] in let filename_sep = del /[ \t\n]+/ " " in let filenames = Build.opt_list filename filename_sep in [ label "rule" . filenames . Build.block entry ]
A minimalistic logrotate block
let combine_two = let entry (k:string) = [ key k ] in Build.combine_two (entry "a") (entry "b")
A minimalistic combination lens
let combine_two_opt = let entry (k:string) = [ key k ] in Build.combine_two_opt (entry "a") (entry "b")
A minimalistic optional combination lens
let combine_three = let entry (k:string) = [ key k ] in Build.combine_three (entry "a") (entry "b") (entry "c")
A minimalistic optional combination lens
let combine_three_opt = let entry (k:string) = [ key k ] in Build.combine_three_opt (entry "a") (entry "b") (entry "c")
A minimalistic optional combination lens
Close