tests for functions in Arg, Stdin, Locale (#368)

* test untested env functions

* use Path.display

* tests for functions in Arg, Stdin, Locale

* cleanup

* fix locale

Author: Anton-4

ci/all_tests.sh

@@ -101,8 +101,8 @@ rm -rf dirExampleD
 for roc_file in $EXAMPLES_DIR*.roc; do
     base_file=$(basename "$roc_file")
 
-    # countdown, echo, form, piping... all require user input or special setup
-    ignore_list=("stdin-basic.roc" "piping.roc" "command-line-args.roc" "http.roc" "env-var.roc" "bytes-stdin-stdout.roc" "error-handling.roc" "tcp-client.roc")
+    # countdown, echo, form... all require user input or special setup
+    ignore_list=("stdin-basic.roc" "stdin-pipe.roc" "command-line-args.roc" "http.roc" "env-var.roc" "bytes-stdin-stdout.roc" "error-handling.roc" "tcp-client.roc")
 
     # check if base_file matches something from ignore_list
     for file in "${ignore_list[@]}"; do

ci/expect_scripts/command-line-args.exp

@@ -11,8 +11,12 @@ source ./ci/expect_scripts/shared-code.exp
 
 
 expect "received argument: foo\r\n" {
-    expect eof {
-        check_exit_and_segfault
+    expect "Unix argument, bytes: \\\[102, 111, 111\\\]\r\n" {
+        expect "back to Arg: \"foo\"\r\n" {
+            expect eof {
+                check_exit_and_segfault
+            }
+        }
     }
 }
 

ci/expect_scripts/locale.exp

@@ -0,0 +1,21 @@
+#!/usr/bin/expect
+
+# uncomment line below for debugging
+# exp_internal 1
+
+set timeout 7
+
+source ./ci/expect_scripts/shared-code.exp
+
+spawn $env(EXAMPLES_DIR)locale
+
+expect -re {The most preferred locale for this system or application: [a-zA-Z\-]+\r\n} {
+    expect -re {All available locales for this system or application: \[.*\]\r\n} {
+        expect eof {
+            check_exit_and_segfault
+        }
+    }
+}
+
+puts stderr "\nExpect script failed: output was different from expected value."
+exit 1

ci/expect_scripts/piping.exp ci/expect_scripts/stdin-pipe.expci/expect_scripts/piping.exp renamed to ci/expect_scripts/stdin-pipe.exp

@@ -7,11 +7,11 @@ set timeout 7
 
 source ./ci/expect_scripts/shared-code.exp
 
-# Spawn the command to pipe in the data to the script B
-spawn bash -c "echo -e \"test\n123\" | $env(EXAMPLES_DIR)/piping"
+# -n to make sure Stdin.read_to_end! works without newline in input
 
-# Expect the output
-expect -exact "I read 2 lines from stdin.\r\n" {
+spawn bash -c "echo -n \"hey\" | $env(EXAMPLES_DIR)/stdin-pipe"
+
+expect "This is what you piped in: \"hey\"\r\n" {
     expect eof {
         check_exit_and_segfault
     }

examples/.gitignore

@@ -20,7 +20,7 @@ dup-bytes
 out.txt
 path
 print
-piping
+stdin-pipe
 record-builder
 result
 stdin
@@ -31,4 +31,6 @@ sqlite-test
 task-list
 tcp-client
 time
-bytes-stdin-stdout
+bytes-stdin-stdout
+locale
+piping

examples/command-line-args.roc

@@ -12,12 +12,26 @@ import pf.Arg exposing [Arg]
 main! : List Arg => Result {} _
 main! = |raw_args|
 
-    args = List.map(raw_args, Arg.display)
-
     # get the second argument, the first is the executable's path
-    when List.get(args, 1) |> Result.map_err(|_| ZeroArgsGiven) is
+    when List.get(raw_args, 1) |> Result.map_err(|_| ZeroArgsGiven) is
         Err(ZeroArgsGiven) ->
             Err(Exit(1, "Error ZeroArgsGiven:\n\tI expected one argument, but I got none.\n\tRun the app like this: `roc main.roc -- input.txt`"))
 
         Ok(first_arg) ->
-            Stdout.line!("received argument: ${first_arg}")
+            Stdout.line!("received argument: ${Arg.display(first_arg)}")?
+
+            # # OPTIONAL TIP:
+
+            # If you ever need to pass an arg to a Roc package, it will probably expect an argument with the type `[Unix (List U8), Windows (List U16)]`.
+            # You can convert an Arg to that with `Arg.to_os_raw`.
+            #
+            # Roc packages like to be platform agnostic so that everyone can use them, that's why they avoid platform-specific types like `pf.Arg`.
+            when Arg.to_os_raw(first_arg) is
+                Unix(bytes) ->
+                    Stdout.line!("Unix argument, bytes: ${Inspect.to_str(bytes)}")?
+
+                Windows(u16s) ->
+                    Stdout.line!("Windows argument, u16s: ${Inspect.to_str(u16s)}")?
+
+            # You can go back with Arg.from_os_raw:
+            Stdout.line!("back to Arg: ${Inspect.to_str(Arg.from_os_raw(Arg.to_os_raw(first_arg)))}")

examples/locale.roc

@@ -0,0 +1,18 @@
+app [main!] { pf: platform "../platform/main.roc" }
+
+import pf.Stdout
+import pf.Arg exposing [Arg]
+import pf.Locale
+
+# Getting the preferred locale and all available locales
+
+# To run this example: check the README.md in this folder
+
+main! : List Arg => Result {} _
+main! = |_args|
+    
+    locale_str = Locale.get!({})?
+    Stdout.line!("The most preferred locale for this system or application: ${locale_str}")?
+
+    all_locales = Locale.all!({})
+    Stdout.line!("All available locales for this system or application: ${Inspect.to_str(all_locales)}")

examples/piping.roc

@@ -0,0 +1,19 @@
+app [main!] { pf: platform "../platform/main.roc" }
+
+import pf.Stdin
+import pf.Stdout
+import pf.Arg exposing [Arg]
+
+# To run this example: check the README.md in this folder
+
+# Reading piped text from stdin, for example: `echo "hey" | roc ./examples/stdin-pipe.roc`
+
+main! : List Arg => Result {} _
+main! = |_args|
+
+    # Data is only sent with Stdin.line! if the user presses Enter,
+    # so you'll need to use read_to_end! to read data that was piped in without a newline.
+    piped_in = Stdin.read_to_end!({})?
+    piped_in_str = Str.from_utf8(piped_in)?
+
+    Stdout.line!("This is what you piped in: \"${piped_in_str}\"")

examples/stdin-pipe.roc

@@ -5,10 +5,10 @@ module [
     from_os_raw,
 ]
 
-## An OS-aware representation of a command-line argument.
+## An OS-aware (see below) representation of a command-line argument.
 ##
-## Though we tend to think of args as Unicode strings, most operating systems
-## represent command-line arguments as lists of bytes that aren't necessarily
+## Though we tend to think of args as Unicode strings, **most operating systems
+## represent command-line arguments as lists of bytes** that aren't necessarily
 ## UTF-8 encoded. Windows doesn't even use bytes, but U16s.
 ##
 ## Most of the time, you will pass these to packages and they will handle the