commit 70f7e41c1fd1100b5f541b5f9f7e49c19009f56e · dunkirk.sh/gleam-bible-search

-2

.gitignore

···

       1
       1
       -
       lab66

     

       2
       2
       -
       lab66.output

     

       3
       1
        
       build/

     

       4
       2
        
       .DS_Store

-64

COVERSHEET.md

···

       1
       1
       -
       ---

     

       2
       2
       -
       Project: "#6"

     

       3
       3
       -
       Professor: "Professor Knoerr"

     

       4
       4
       -
       Class: "CS 1210 – Fall 2025"

     

       5
       5
       -
       Author: "Kieran Klukas"

     

       6
       6
       -
       ---

     

       7
       7
       -
       

     

       8
       8
       -
       # Requirements

     

       9
       9
       -
       

     

       10
       10
       -
       <!--Restate the problem specifications in your own words-->

     

       11
       11
       -
       

     

       12
       12
       -
       Search a provided old testament text file for arbitrary reference. It prompts the user for book, chapter, and verse and then searches for that verse. If book is not found then output `Book does not exist in the Old Testament`. If chapter isn't found then `Chapter # does not exist in Book`. Finally if the verse isn't found then output `Verse # does not exist in Book #`. Once the verse is found then append the verse to `verses.txt`.

     

       13
       13
       -
       

     

       14
       14
       -
       # Design

     

       15
       15
       -
       

     

       16
       16
       -
       <!--How did you attack the problem? What choices did you make in your design, and why?-->

     

       17
       17
       -
       

     

       18
       18
       -
       I started with outlining the basic input system [`532c6cf`](https://github.com/cu-cs1210/lab-6-kieranklukas/commit/5b2ced23798fc7cbce79eb445c9592cccf16d6a6). Then worked on setting up a while loop to read the file line by line. I spent a while puzzling over exactly how I wanted to implement this and I am not entirely satisfied with my current solution. It would be interesting to try this problem in a functional language like gleam or erlang and see how much more cleanly I can parse the file. I implemented each reference part sequentially and then went back and made it check for barrier strings to stay within the proper book and chapter. I ended up realizing that the book of Psalms is referenced differently and so made some logic to permit its idiosyncracies [`7c18fff`](https://github.com/cu-cs1210/lab-6-kieranklukas/commit/7c18fffa30ab3e43bcb05ad4dff44f275987cbb8).

     

       19
       19
       -
       

     

       20
       20
       -
       # Implementation

     

       21
       21
       -
       

     

       22
       22
       -
       <!--Outline any interesting implementation details.-->

     

       23
       23
       -
       

     

       24
       24
       -
       I used a single input variable to parse the file word by word until we get to the correct verse. I also check if the input book is listed as `Psalm` or `Psalms` and add or remove an `s` when doing checks or output as appropriate. The output file is also never opened until we find the verse and is immediately closed afterward. Also a minor note of intrest is that you can change the default paths that the program loads from and saves to by adding the paths as arguments (eg. `lab66 test/OT.txt build/verses.txt`).

     

       25
       25
       -
       

     

       26
       26
       -
       # Testing

     

       27
       27
       -
       

     

       28
       28
       -
       <!--

     

       29
       29
       -
       Explain how you tested your program, enumerating the tests if possible.

     

       30
       30
       -
       Explain why your test set was sufficient to believe that the software is working properly,

     

       31
       31
       -
       i.e., what were the range of possibilities of errors that you were testing for.

     

       32
       32
       -
       -->

     

       33
       33
       -
       

     

       34
       34
       -
       I updated the `makefile` to add `make run` so I could compile and run it more easily and updated the test file to have the Zylabs test states as well as more granularly check a happy path and some adversarial paths.

     

       35
       35
       -
       

     

       36
       36
       -
       # Outside Help

     

       37
       37
       -
       

     

       38
       38
       -
       <!--Did you get help from anyone else on this project? Document their contribution to your learning.-->

     

       39
       39
       -
       

     

       40
       40
       -
       No outside help was used beyond minor googling for how to capitalize an entire string and the proper syntax for appending (not covered in zybooks as far as I can tell but I'm sure you will cover it in lectures next week).

     

       41
       41
       -
       

     

       42
       42
       -
       # Summary/Conclusion

     

       43
       43
       -
       

     

       44
       44
       -
       <!--Present your results. Did it work properly? Are there any limitations?-->

     

       45
       45
       -
       

     

       46
       46
       -
       The program works well and should cover most edgecases! As far as I can tell there isn't anything that should be able to break it beyond changing the `OT.txt` to be several GB in size.

     

       47
       47
       -
       

     

       48
       48
       -
       # AI Use

     

       49
       49
       -
       

     

       50
       50
       -
       <!--How did you use Generative AI in this project?-->

     

       51
       51
       -
       

     

       52
       52
       -
       I used claude to generate a more complex test file and then modified it to add the rest of the zybooks tests as I got closer to finishing the project.

     

       53
       53
       -
       

     

       54
       54
       -
       # Lessons Learned

     

       55
       55
       -
       

     

       56
       56
       -
       <!--List any lessons learned. What might you have done differently if you were going to attack this again.-->

     

       57
       57
       -
       

     

       58
       58
       -
       I would definetly want to try a different language for sure if I was doing this independantly but overal I think this implementation is fairly solid and I wouldn't change much. I did find out in this lab that it is always a good idea to check the whole input or you might run into weird bugs like how `PSALMS` is formatted.

     

       59
       59
       -
       

     

       60
       60
       -
       # Time Spent

     

       61
       61
       -
       

     

       62
       62
       -
       <!--Approximately how many hours did you spend on this project?-->

     

       63
       63
       -
       

     

       64
       64
       -
       ![hackatime badge](https://hackatime-badge.hackclub.com/U062UG485EE/lab-6)

+15 -63

README.md

···

       1
       1
       -
       # Lab 6

     

       2
       2
       -
       

     

       3
       3
       -
       ![screenshot of the code generated by freeze](docs/freeze.jpeg)

     

       4
       4
       -
       

     

       5
       5
       -
       For this lab the program must parse `OT.txt` (format below) to find specific references and produce scoped errors if the reference isn't found.

     

       6
       6
       -
       

     

       7
       7
       -
       ```text

     

       8
       8
       -
       THE BOOK OF GENESIS

     

       9
       9
       -
       

     

       10
       10
       -
       CHAPTER 1

     

       11
       11
       -
       1 In the beginning God created the heaven and the earth.

     

       12
       12
       -
       2 And the earth was without form, and void; and darkness [was] upon the face of the deep. And the Spirit of God moved upon the face of the waters.

     

       13
       13
       -
       3 And God said, Let there be light: and there was light.

     

       14
       14
       -
       4 And God saw the light, that [it was] good: and God divided the light from the darkness.

     

       1
       1
       +
       # bible_search_gleam

     

       15
       2
        
       

     

       16
       16
       -
       THE BOOK OF PSALMS

     

       3
       3
       +
       [![Package Version](https://img.shields.io/hexpm/v/bible_search_gleam)](https://hex.pm/packages/bible_search_gleam)

     

       4
       4
       +
       [![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/bible_search_gleam/)

     

       17
       5
        
       

     

       18
       18
       -
       PSALM 1

     

       19
       19
       -
       1 Blessed [is] the man that walketh not in the counsel of the ungodly, nor standeth in the way of sinners, nor sitteth in the seat of the scornful.

     

       20
       20
       -
       2 But his delight [is] in the law of the LORD; and in his law doth he meditate day and night.

     

       21
       21
       -
       3 And he shall be like a tree planted by the rivers of water, that bringeth forth his fruit in his season; his leaf also shall not wither; and whatsoever he doeth shall prosper.

     

       6
       6
       +
       ```sh

     

       7
       7
       +
       gleam add bible_search_gleam@1

     

       22
       8
        
       ```

     

       23
       23
       -
       

     

       24
       24
       -
       The project is layed out as follows:

     

       25
       25
       -
       

     

       26
       26
       -
       ```bash

     

       27
       27
       -
       .

     

       28
       28
       -
       ├── build # this directory isn't committed and is ephemeral

     

       29
       29
       -
       │   └── lab66

     

       30
       30
       -
       ├── COVERSHEET.md

     

       31
       31
       -
       ├── LICENSE.md

     

       32
       32
       -
       ├── makefile

     

       33
       33
       -
       ├── README.md

     

       34
       34
       -
       ├── src

     

       35
       35
       -
       │   └── lab66.cpp

     

       36
       36
       -
       └── test

     

       37
       37
       -
           ├── OT.txt

     

       38
       38
       -
           └── test.sh

     

       9
       9
       +
       ```gleam

     

       10
       10
       +
       import bible_search_gleam

     

       39
       11
        
       

     

       40
       40
       -
       4 directories, 8 files

     

       12
       12
       +
       pub fn main() -> Nil {

     

       13
       13
       +
         // TODO: An example of the project in use

     

       14
       14
       +
       }

     

       41
       15
        
       ```

     

       42
       16
        
       

     

       43
       43
       -
       ### Build scripts

     

       17
       17
       +
       Further documentation can be found at <https://hexdocs.pm/bible_search_gleam>.

     

       44
       18
        
       

     

       45
       45
       -
       The preferred way to run the program is through make:

     

       19
       19
       +
       ## Development

     

       46
       20
        
       

     

       47
       47
       -
       ```bash

     

       48
       48
       -
       make # compiles and runs tests

     

       49
       49
       -
       make run # compiles and runs the program

     

       50
       50
       -
       make clean # clean up the build dir

     

       21
       21
       +
       ```sh

     

       22
       22
       +
       gleam run   # Run the project

     

       23
       23
       +
       gleam test  # Run the tests

     

       51
       24
        
       ```

     

       52
       52
       -
       

     

       53
       53
       -
       it is however possible to still do things manually:

     

       54
       54
       -
       

     

       55
       55
       -
       ```bash

     

       56
       56
       -
       mkdir build

     

       57
       57
       -
       cd build

     

       58
       58
       -
       g++ ../src/lab66.cpp -o lab66

     

       59
       59
       -
       ./lab66 ../test/OT.txt verses.txt

     

       60
       60
       -
       ```

     

       61
       61
       -
       

     

       62
       62
       -
       <p align="center">

     

       63
       63
       -
           <img src="https://raw.githubusercontent.com/taciturnaxolotl/carriage/main/.github/images/line-break.svg" />

     

       64
       64
       -
       </p>

     

       65
       65
       -
       

     

       66
       66
       -
       <p align="center">

     

       67
       67
       -
           <i><code>&copy 2025-present <a href="https://github.com/taciturnaxololt">Kieran Klukas</a></code></i>

     

       68
       68
       -
       </p>

     

       69
       69
       -
       

     

       70
       70
       -
       <p align="center">

     

       71
       71
       -
           <a href="https://github.com/cu-cs1210/lab-6-kieranklukas/blob/main/LICENSE.md"><img src="https://img.shields.io/static/v1.svg?style=for-the-badge&label=License&message=MIT&logoColor=d9e0ee&colorA=363a4f&colorB=b7bdf8"/></a>

     

       72
       72
       -
       </p>

docs/freeze.jpeg

This is a binary file and will not be displayed.

+21

gleam.toml

···

       1
       1
       +
       name = "bible_search"

     

       2
       2
       +
       version = "1.0.0"

     

       3
       3
       +
       

     

       4
       4
       +
       # Fill out these fields if you intend to generate HTML documentation or publish

     

       5
       5
       +
       # your project to the Hex package manager.

     

       6
       6
       +
       #

     

       7
       7
       +
       # description = ""

     

       8
       8
       +
       # licences = ["Apache-2.0"]

     

       9
       9
       +
       # repository = { type = "github", user = "", repo = "" }

     

       10
       10
       +
       # links = [{ title = "Website", href = "" }]

     

       11
       11
       +
       #

     

       12
       12
       +
       # For a full reference of all the available options, you can have a look at

     

       13
       13
       +
       # https://gleam.run/writing-gleam/gleam-toml/.

     

       14
       14
       +
       

     

       15
       15
       +
       [dependencies]

     

       16
       16
       +
       gleam_stdlib = ">= 0.44.0 and < 2.0.0"

     

       17
       17
       +
       simplifile = ">= 2.3.0 and < 3.0.0"

     

       18
       18
       +
       input = ">= 1.0.1 and < 2.0.0"

     

       19
       19
       +
       

     

       20
       20
       +
       [dev-dependencies]

     

       21
       21
       +
       gleeunit = ">= 1.0.0 and < 2.0.0"

-16

makefile

···

       1
       1
       -
       all: lab66 test

     

       2
       2
       -
       

     

       3
       3
       -
       lab66: src/lab66.cpp

     

       4
       4
       -
       	mkdir -p build && g++ src/lab66.cpp -Wall -o build/lab66

     

       5
       5
       -
       

     

       6
       6
       -
       test: lab66

     

       7
       7
       -
       	cd test && ./test.sh

     

       8
       8
       -
       

     

       9
       9
       -
       exec:

     

       10
       10
       -
       	./build/lab66 test/OT.txt build/verses.txt

     

       11
       11
       -
       

     

       12
       12
       -
       run: lab66 exec

     

       13
       13
       -
       

     

       14
       14
       -
       clean:

     

       15
       15
       -
       	rm -rf build

     

       16
       16
       -

+16

manifest.toml

···

       1
       1
       +
       # This file was generated by Gleam

     

       2
       2
       +
       # You typically do not need to edit this file

     

       3
       3
       +
       

     

       4
       4
       +
       packages = [

     

       5
       5
       +
         { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },

     

       6
       6
       +
         { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },

     

       7
       7
       +
         { name = "gleeunit", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "FDC68A8C492B1E9B429249062CD9BAC9B5538C6FBF584817205D0998C42E1DAC" },

     

       8
       8
       +
         { name = "input", version = "1.0.1", build_tools = ["gleam"], requirements = [], otp_app = "input", source = "hex", outer_checksum = "FE84CDADC78A1367E4AFD561A529825A8FEC88D165CBDF511FD3226CABCDEE6F" },

     

       9
       9
       +
         { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },

     

       10
       10
       +
       ]

     

       11
       11
       +
       

     

       12
       12
       +
       [requirements]

     

       13
       13
       +
       gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }

     

       14
       14
       +
       gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

     

       15
       15
       +
       input = { version = ">= 1.0.1 and < 2.0.0" }

     

       16
       16
       +
       simplifile = { version = ">= 2.3.0 and < 3.0.0" }

+47

src/bible_search.gleam

···

       1
       1
       +
       import gleam/int

     

       2
       2
       +
       import gleam/io

     

       3
       3
       +
       import gleam/list

     

       4
       4
       +
       import gleam/string

     

       5
       5
       +
       import input.{input}

     

       6
       6
       +
       import simplifile

     

       7
       7
       +
       

     

       8
       8
       +
       const filepath = "./OT.txt"

     

       9
       9
       +
       

     

       10
       10
       +
       pub type Reference {

     

       11
       11
       +
         Reference(book: String, chapter: Int, verse: Int)

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       pub fn parse_reference(input: String) -> Result(Reference, String) {

     

       15
       15
       +
         let parts = string.split(input, on: " ")

     

       16
       16
       +
       

     

       17
       17
       +
         case parts {

     

       18
       18
       +
           [book, chapter_s, verse_s] ->

     

       19
       19
       +
             case int.parse(chapter_s) {

     

       20
       20
       +
               Ok(chapter) ->

     

       21
       21
       +
                 case int.parse(verse_s) {

     

       22
       22
       +
                   Ok(verse) ->

     

       23
       23
       +
                     Ok(Reference(book: string.uppercase(book), chapter:, verse:))

     

       24
       24
       +
                   Error(_) -> Error("Invalid verse" <> verse_s)

     

       25
       25
       +
                 }

     

       26
       26
       +
               Error(_) -> Error("Invalid chapter" <> chapter_s)

     

       27
       27
       +
             }

     

       28
       28
       +
           _ -> Error("invalid parse")

     

       29
       29
       +
         }

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       pub fn main() -> Nil {

     

       33
       33
       +
         let assert Ok(bible) = simplifile.read(from: filepath)

     

       34
       34
       +
       

     

       35
       35
       +
         let biblelines = string.split(bible, on: "\n")

     

       36
       36
       +
       

     

       37
       37
       +
         let assert Ok(search) = input(prompt: "> ")

     

       38
       38
       +
       

     

       39
       39
       +
         let assert Ok(reference) = parse_reference(search)

     

       40
       40
       +
       

     

       41
       41
       +
         list.each(biblelines, fn(line) {

     

       42
       42
       +
           case line {

     

       43
       43
       +
             "THE BOOK OF " <> book if book == reference.book -> io.println(book)

     

       44
       44
       +
             _ -> io.print("")

     

       45
       45
       +
           }

     

       46
       46
       +
         })

     

       47
       47
       +
       }

-143

src/lab66.cpp

···

       1
       1
       -
       /*********************************************************

     

       2
       2
       -
       * Summary: find verses from the old testament

     

       3
       3
       -
       * appending them to file as found

     

       4
       4
       -
       *

     

       5
       5
       -
       * Author: Kieran Klukas

     

       6
       6
       -
       * Created: October 2025

     

       7
       7
       -
       *

     

       8
       8
       -
       ********************************************************/

     

       9
       9
       -
       

     

       10
       10
       -
       #include <iostream>

     

       11
       11
       -
       #include <cstdlib>

     

       12
       12
       -
       #include <fstream>

     

       13
       13
       -
       

     

       14
       14
       -
       using namespace std;

     

       15
       15
       -
       

     

       16
       16
       -
       int main(int argc, char **argv) {

     

       17
       17
       -
       

     

       18
       18
       -
          ifstream OT;

     

       19
       19
       -
          ofstream OF;

     

       20
       20
       -
          string inputFilename = "OT.txt";

     

       21
       21
       -
          string outputFilename = "verses.txt";

     

       22
       22
       -
       

     

       23
       23
       -
          string book;

     

       24
       24
       -
          string normalizedBook;

     

       25
       25
       -
          int chapter;

     

       26
       26
       -
          int verse;

     

       27
       27
       -
       

     

       28
       28
       -
          // get path to OT.txt if provided otherwise use default path

     

       29
       29
       -
          // and then do the same for the verses.txt

     

       30
       30
       -
          if (argc >= 2) inputFilename = argv[1];

     

       31
       31
       -
          if (argc >= 3) outputFilename = argv[2];

     

       32
       32
       -
       

     

       33
       33
       -
          OT.open(inputFilename);

     

       34
       34
       -
       

     

       35
       35
       -
          if (!OT.is_open()) {

     

       36
       36
       -
             cout << inputFilename << ": failed to open file";

     

       37
       37
       -
             return 1;

     

       38
       38
       -
          }

     

       39
       39
       -
       

     

       40
       40
       -
          cout << "Please enter the reference of the verse you would like" << endl;

     

       41
       41
       -
       

     

       42
       42
       -
          cout << "the book: ";

     

       43
       43
       -
          getline(cin, book);

     

       44
       44
       -
          for (int i = 0; i < book.length(); i++)

     

       45
       45
       -
               normalizedBook += toupper(book[i]);

     

       46
       46
       -
          if (normalizedBook == "PSALMS")

     

       47
       47
       -
             normalizedBook = "PSALM";

     

       48
       48
       -
       

     

       49
       49
       -
          cout << "the chapter: ";

     

       50
       50
       -
          cin >> chapter;

     

       51
       51
       -
       

     

       52
       52
       -
          cout << "the verse: ";

     

       53
       53
       -
          cin >> verse;

     

       54
       54
       -
       

     

       55
       55
       -
          cout << endl;

     

       56
       56
       -
       

     

       57
       57
       -
          bool foundBook = false;

     

       58
       58
       -
          bool foundChapter = false;

     

       59
       59
       -
          bool foundVerse = false;

     

       60
       60
       -
          string verseString;

     

       61
       61
       -
          while (!OT.eof()) {

     

       62
       62
       -
             string input;

     

       63
       63
       -
       

     

       64
       64
       -
             if (!foundBook) {

     

       65
       65
       -
                OT >> input; // THE

     

       66
       66
       -
                if (input != "THE") continue;

     

       67
       67
       -
                OT >> input; // BOOK

     

       68
       68
       -
                if (input != "BOOK") continue;

     

       69
       69
       -
                OT >> input; // OF

     

       70
       70
       -
                if (input != "OF") continue;

     

       71
       71
       -
       

     

       72
       72
       -
                OT.ignore(); // skip the single space

     

       73
       73
       -
       

     

       74
       74
       -
                getline(OT, input); // handle multi word books

     

       75
       75
       -
       

     

       76
       76
       -
                // second check is for the book of psalms

     

       77
       77
       -
                if (input == normalizedBook || input == (normalizedBook + "S")) {

     

       78
       78
       -
                   foundBook = true;

     

       79
       79
       -
       

     

       80
       80
       -
                   getline(OT, input); // discard empty line

     

       81
       81
       -
                   continue;

     

       82
       82
       -
                }

     

       83
       83
       -
             } else {

     

       84
       84
       -
                if (!foundChapter) {

     

       85
       85
       -
                   OT >> input;

     

       86
       86
       -
                   if (input != "CHAPTER" && input != "PSALM") {

     

       87
       87
       -
                      if (input == "THE") break;

     

       88
       88
       -
       

     

       89
       89
       -
                      continue;

     

       90
       90
       -
                   }

     

       91
       91
       -
       

     

       92
       92
       -
                   OT >> input;

     

       93
       93
       -
                   if (input == to_string(chapter)) {

     

       94
       94
       -
                      foundChapter = true;

     

       95
       95
       -
                      continue;

     

       96
       96
       -
                   }

     

       97
       97
       -
                } else {

     

       98
       98
       -
                   OT >> input;

     

       99
       99
       -
       

     

       100
       100
       -
                   if (input == "CHAPTER" || input == "PSALM") break;

     

       101
       101
       -
       

     

       102
       102
       -
                   if (input == to_string(verse)) {

     

       103
       103
       -
                      foundVerse = true;

     

       104
       104
       -
                      OT.ignore(); // ignore space

     

       105
       105
       -
                      getline(OT, verseString);

     

       106
       106
       -
                      break;

     

       107
       107
       -
                   }

     

       108
       108
       -
                }

     

       109
       109
       -
             }

     

       110
       110
       -
          }

     

       111
       111
       -
       

     

       112
       112
       -
          if (foundVerse) {

     

       113
       113
       -
             cout << verse << " " << verseString << endl;

     

       114
       114
       -
       

     

       115
       115
       -
             OF.open(outputFilename, ios_base::app);

     

       116
       116
       -
       

     

       117
       117
       -
             if (!OF.is_open()) {

     

       118
       118
       -
                cout << outputFilename << ": error saving file" << endl;

     

       119
       119
       -
                return 1;

     

       120
       120
       -
             }

     

       121
       121
       -
       

     

       122
       122
       -
             OF << verse << " " << verseString << endl;

     

       123
       123
       -
       

     

       124
       124
       -
             OF.close();

     

       125
       125
       -
          } else {

     

       126
       126
       -
             if (!foundBook) {

     

       127
       127
       -
                cout << (normalizedBook == "PSALM" ? book += "s" : book) << " does not exist in the Old Testament";

     

       128
       128
       -
             } else {

     

       129
       129
       -
                if (!foundChapter) {

     

       130
       130
       -
                   cout << (normalizedBook == "PSALM" ? "Psalm " : "Chapter ") << chapter;

     

       131
       131
       -
                   cout << " does not exist in " << (normalizedBook == "PSALM" ? book += "s" : book);

     

       132
       132
       -
                } else if (!foundVerse) {

     

       133
       133
       -
                   cout << "Verse " << verse << " does not exist in " << book << " " << chapter;

     

       134
       134
       -
                }

     

       135
       135
       -
             }

     

       136
       136
       -
       

     

       137
       137
       -
             cout << endl;

     

       138
       138
       -
          }

     

       139
       139
       -
       

     

       140
       140
       -
          OT.close();

     

       141
       141
       -
       

     

       142
       142
       -
          return 0;

     

       143
       143
       -
       }

test/OT.txt OT.txt

+13

test/bible_search_gleam_test.gleam

···

       1
       1
       +
       import gleeunit

     

       2
       2
       +
       

     

       3
       3
       +
       pub fn main() -> Nil {

     

       4
       4
       +
         gleeunit.main()

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       // gleeunit test functions end in `_test`

     

       8
       8
       +
       pub fn hello_world_test() {

     

       9
       9
       +
         let name = "Joe"

     

       10
       10
       +
         let greeting = "Hello, " <> name <> "!"

     

       11
       11
       +
       

     

       12
       12
       +
         assert greeting == "Hello, Joe!"

     

       13
       13
       +
       }

-362

test/test.sh

···

       1
       1
       -
       #!/bin/bash

     

       2
       2
       -
       

     

       3
       3
       -
       # Test script with configurable timeout support

     

       4
       4
       -
       # Usage: ./test.sh [timeout_seconds]

     

       5
       5
       -
       # Example: ./test.sh 5 (uses 5 second timeout)

     

       6
       6
       -
       # Default: 1 second timeout

     

       7
       7
       -
       

     

       8
       8
       -
       # Colors for output

     

       9
       9
       -
       RED='\033[0;31m'

     

       10
       10
       -
       GREEN='\033[0;32m'

     

       11
       11
       -
       YELLOW='\033[1;33m'

     

       12
       12
       -
       BLUE='\033[0;34m'

     

       13
       13
       -
       NC='\033[0m' # No Color

     

       14
       14
       -
       

     

       15
       15
       -
       # Test configuration

     

       16
       16
       -
       temp_file="lab66.output"

     

       17
       17
       -
       program="../build/lab66"

     

       18
       18
       -
       output_file="../build/verses.txt"

     

       19
       19
       -
       test_timeout=${1:-1}

     

       20
       20
       -
       

     

       21
       21
       -
       # Test counters

     

       22
       22
       -
       total_tests=0

     

       23
       23
       -
       passed_tests=0

     

       24
       24
       -
       

     

       25
       25
       -
       # Cleanup function

     

       26
       26
       -
       cleanup() {

     

       27
       27
       -
           rm -f "$temp_file" "$output_file"

     

       28
       28
       -
       }

     

       29
       29
       -
       

     

       30
       30
       -
       # Error trap

     

       31
       31
       -
       trap cleanup EXIT ERR

     

       32
       32
       -
       

     

       33
       33
       -
       # Function to print test results

     

       34
       34
       -
       print_result() {

     

       35
       35
       -
           local test_name="$1"

     

       36
       36
       -
           local result="$2"

     

       37
       37
       -
           local message="$3"

     

       38
       38
       -
       

     

       39
       39
       -
           total_tests=$((total_tests + 1))

     

       40
       40
       -
       

     

       41
       41
       -
           if [ "$result" = "PASS" ]; then

     

       42
       42
       -
               echo -e "${GREEN}[PASS]${NC} $test_name: $message"

     

       43
       43
       -
               passed_tests=$((passed_tests + 1))

     

       44
       44
       -
           elif [ "$result" = "TIMEOUT" ]; then

     

       45
       45
       -
               echo -e "${YELLOW}[TIMEOUT]${NC} $test_name: $message"

     

       46
       46
       -
           else

     

       47
       47
       -
               echo -e "${RED}[FAIL]${NC} $test_name: $message"

     

       48
       48
       -
           fi

     

       49
       49
       -
       }

     

       50
       50
       -
       

     

       51
       51
       -
       # Function to print test section header

     

       52
       52
       -
       print_section() {

     

       53
       53
       -
           echo -e "\n${BLUE}=== $1 ===${NC}"

     

       54
       54
       -
       }

     

       55
       55
       -
       

     

       56
       56
       -
       # Build program if needed

     

       57
       57
       -
       if [ ! -f "$program" ]; then

     

       58
       58
       -
           print_section "Building Program"

     

       59
       59
       -
           cd .. && make lab66 > /dev/null 2>&1

     

       60
       60
       -
           build_result=$?

     

       61
       61
       -
           cd test

     

       62
       62
       -
           if [ $build_result -ne 0 ]; then

     

       63
       63
       -
               print_result "Program Build" "FAIL" "Could not build $program"

     

       64
       64
       -
               exit 1

     

       65
       65
       -
           fi

     

       66
       66
       -
           print_result "Program Build" "PASS" "Program built successfully"

     

       67
       67
       -
       fi

     

       68
       68
       -
       

     

       69
       69
       -
       # Test 1: Program compilation/existence

     

       70
       70
       -
       if [ ! -f "$program" ]; then

     

       71
       71
       -
           print_section "Test 1: Program Availability"

     

       72
       72
       -
           print_result "Program Existence" "FAIL" "Program $program not found"

     

       73
       73
       -
           exit 1

     

       74
       74
       -
       fi

     

       75
       75
       -
       

     

       76
       76
       -
       # Test 2: Basic Bible Verse Lookup Test (Genesis 1:1)

     

       77
       77
       -
       print_section "Basic Bible Verse Lookup Test"

     

       78
       78
       -
       

     

       79
       79
       -
       # Test with known valid verse

     

       80
       80
       -
       basic_input="Genesis\n1\n1"

     

       81
       81
       -
       resp=$(timeout "$test_timeout" bash -c "echo -e '$basic_input' | '$program' OT.txt '$output_file'" 2>&1)

     

       82
       82
       -
       exit_code=$?

     

       83
       83
       -
       

     

       84
       84
       -
       # Print the output

     

       85
       85
       -
       if [ -n "$resp" ]; then

     

       86
       86
       -
           echo "$resp"

     

       87
       87
       -
       else

     

       88
       88
       -
           echo "(No output produced)"

     

       89
       89
       -
       fi

     

       90
       90
       -
       echo

     

       91
       91
       -
       

     

       92
       92
       -
       if [ $exit_code -eq 124 ]; then

     

       93
       93
       -
           print_result "Basic Execution" "TIMEOUT" "Program timed out after ${test_timeout}s"

     

       94
       94
       -
           exit 1

     

       95
       95
       -
       elif [ $exit_code -ne 0 ]; then

     

       96
       96
       -
           print_result "Basic Execution" "FAIL" "Program exited with code $exit_code"

     

       97
       97
       -
           exit 1

     

       98
       98
       -
       else

     

       99
       99
       -
           print_result "Basic Execution" "PASS" "Program executed successfully"

     

       100
       100
       -
       fi

     

       101
       101
       -
       

     

       102
       102
       -
       # Check if output contains required prompts

     

       103
       103
       -
       if [[ "$resp" == *"Please enter the reference of the verse you would like"* ]]; then

     

       104
       104
       -
           print_result "Initial Prompt" "PASS" "Program shows initial prompt"

     

       105
       105
       -
       else

     

       106
       106
       -
           print_result "Initial Prompt" "FAIL" "Program missing initial prompt"

     

       107
       107
       -
       fi

     

       108
       108
       -
       

     

       109
       109
       -
       if [[ "$resp" == *"the book:"* ]]; then

     

       110
       110
       -
           print_result "Book Prompt" "PASS" "Program prompts for book"

     

       111
       111
       -
       else

     

       112
       112
       -
           print_result "Book Prompt" "FAIL" "Program missing book prompt"

     

       113
       113
       -
       fi

     

       114
       114
       -
       

     

       115
       115
       -
       if [[ "$resp" == *"the chapter:"* ]]; then

     

       116
       116
       -
           print_result "Chapter Prompt" "PASS" "Program prompts for chapter"

     

       117
       117
       -
       else

     

       118
       118
       -
           print_result "Chapter Prompt" "FAIL" "Program missing chapter prompt"

     

       119
       119
       -
       fi

     

       120
       120
       -
       

     

       121
       121
       -
       if [[ "$resp" == *"the verse:"* ]]; then

     

       122
       122
       -
           print_result "Verse Prompt" "PASS" "Program prompts for verse"

     

       123
       123
       -
       else

     

       124
       124
       -
           print_result "Verse Prompt" "FAIL" "Program missing verse prompt"

     

       125
       125
       -
       fi

     

       126
       126
       -
       

     

       127
       127
       -
       # Check for verse output format

     

       128
       128
       -
       if [[ "$resp" == *"1 In the beginning God created the heaven and the earth"* ]]; then

     

       129
       129
       -
           print_result "Verse Format" "PASS" "Program outputs verse in correct format"

     

       130
       130
       -
       else

     

       131
       131
       -
           print_result "Verse Format" "FAIL" "Program missing or incorrect verse format"

     

       132
       132
       -
       fi

     

       133
       133
       -
       

     

       134
       134
       -
       # Check if test/verses.txt file was created

     

       135
       135
       -
       if [ -f "$output_file" ]; then

     

       136
       136
       -
           verses_content=$(cat "$output_file")

     

       137
       137
       -
           if [[ "$verses_content" == *"In the beginning God created the heaven and the earth"* ]]; then

     

       138
       138
       -
               print_result "File Output" "PASS" "verses.txt created with correct content in build directory"

     

       139
       139
       -
           else

     

       140
       140
       -
               print_result "File Output" "FAIL" "verses.txt has incorrect content"

     

       141
       141
       -
           fi

     

       142
       142
       -
       else

     

       143
       143
       -
           print_result "File Output" "FAIL" "verses.txt file not created in build directory"

     

       144
       144
       -
       fi

     

       145
       145
       -
       

     

       146
       146
       -
       # Function to run verse lookup test

     

       147
       147
       -
       run_verse_test() {

     

       148
       148
       -
           local test_name="$1"

     

       149
       149
       -
           local book="$2"

     

       150
       150
       -
           local chapter="$3"

     

       151
       151
       -
           local verse="$4"

     

       152
       152
       -
           local expected_pattern="$5"

     

       153
       153
       -
           local should_create_file="$6"

     

       154
       154
       -
       

     

       155
       155
       -
           # Clean up previous test

     

       156
       156
       -
           rm -f "$output_file"

     

       157
       157
       -
       

     

       158
       158
       -
           input="$book\n$chapter\n$verse"

     

       159
       159
       -
           output=$(timeout "$test_timeout" bash -c "echo -e '$input' | '$program' OT.txt '$output_file'" 2>&1)

     

       160
       160
       -
           exit_code=$?

     

       161
       161
       -
       

     

       162
       162
       -
           if [ $exit_code -eq 124 ]; then

     

       163
       163
       -
               print_result "$test_name" "TIMEOUT" "Program timed out after ${test_timeout}s"

     

       164
       164
       -
               return

     

       165
       165
       -
           elif [ $exit_code -ne 0 ]; then

     

       166
       166
       -
               print_result "$test_name" "FAIL" "Program crashed (exit code $exit_code)"

     

       167
       167
       -
               return

     

       168
       168
       -
           fi

     

       169
       169
       -
       

     

       170
       170
       -
           # Check if expected pattern is found in output

     

       171
       171
       -
           pattern_found=false

     

       172
       172
       -
           if [[ "$output" == *"$expected_pattern"* ]]; then

     

       173
       173
       -
               pattern_found=true

     

       174
       174
       -
           fi

     

       175
       175
       -
       

     

       176
       176
       -
           # For tests expecting specific output, pattern must be found

     

       177
       177
       -
           if [ -n "$expected_pattern" ] && [ "$pattern_found" = "false" ]; then

     

       178
       178
       -
               print_result "$test_name" "FAIL" "Expected '$expected_pattern' not found in output"

     

       179
       179
       -
               return

     

       180
       180
       -
           fi

     

       181
       181
       -
       

     

       182
       182
       -
           # Check file creation expectations

     

       183
       183
       -
           if [ "$should_create_file" = "true" ]; then

     

       184
       184
       -
               if [ -f "$output_file" ] && [ "$pattern_found" = "true" ]; then

     

       185
       185
       -
                   print_result "$test_name" "PASS" "Expected output found and file created"

     

       186
       186
       -
               elif [ ! -f "$output_file" ]; then

     

       187
       187
       -
                   print_result "$test_name" "FAIL" "Expected file verses.txt not created in build directory"

     

       188
       188
       -
               else

     

       189
       189
       -
                   print_result "$test_name" "FAIL" "File created but expected output not found"

     

       190
       190
       -
               fi

     

       191
       191
       -
           else

     

       192
       192
       -
               if [ ! -f "$output_file" ] && [ "$pattern_found" = "true" ]; then

     

       193
       193
       -
                   print_result "$test_name" "PASS" "Expected error output and no file created"

     

       194
       194
       -
               elif [ -f "$output_file" ]; then

     

       195
       195
       -
                   print_result "$test_name" "FAIL" "verses.txt file should not be created for error cases"

     

       196
       196
       -
               else

     

       197
       197
       -
                   print_result "$test_name" "FAIL" "Expected error message not found"

     

       198
       198
       -
               fi

     

       199
       199
       -
           fi

     

       200
       200
       -
       }

     

       201
       201
       -
       

     

       202
       202
       -
       # Valid Verse Tests

     

       203
       203
       -
       print_section "Valid Verse Tests"

     

       204
       204
       -
       

     

       205
       205
       -
       run_verse_test "Exodus 20:3" "Exodus" "20" "3" "3 Thou shalt have no other gods before me" true

     

       206
       206
       -
       run_verse_test "Psalm 23:1" "Psalm" "23" "1" "1 The LORD [is] my shepherd; I shall not want." true

     

       207
       207
       -
       

     

       208
       208
       -
       # Error Case Tests

     

       209
       209
       -
       print_section "Error Case Tests"

     

       210
       210
       -
       

     

       211
       211
       -
       run_verse_test "Invalid Book" "Matthew" "1" "1" "Matthew does not exist in the Old Testament" false

     

       212
       212
       -
       run_verse_test "Invalid Chapter" "Esther" "18" "3" "Chapter 18 does not exist in Esther" false

     

       213
       213
       -
       run_verse_test "Invalid Verse" "Psalm" "117" "5" "Verse 5 does not exist in Psalm 117" false

     

       214
       214
       -
       

     

       215
       215
       -
       # Adversarial Testing Section

     

       216
       216
       -
       print_section "Adversarial Tests"

     

       217
       217
       -
       

     

       218
       218
       -
       # Test edge cases

     

       219
       219
       -
       run_verse_test "Empty Book Name" "" "1" "1" "Please enter the reference" false

     

       220
       220
       -
       run_verse_test "Non-numeric Chapter" "Genesis" "abc" "1" "Please enter the reference" false

     

       221
       221
       -
       run_verse_test "Non-numeric Verse" "Genesis" "1" "xyz" "Please enter the reference" false

     

       222
       222
       -
       run_verse_test "Zero Chapter" "Genesis" "0" "1" "Please enter the reference" false

     

       223
       223
       -
       run_verse_test "Zero Verse" "Genesis" "1" "0" "Please enter the reference" false

     

       224
       224
       -
       run_verse_test "Negative Chapter" "Genesis" "-1" "1" "Please enter the reference" false

     

       225
       225
       -
       run_verse_test "Negative Verse" "Genesis" "1" "-1" "Please enter the reference" false

     

       226
       226
       -
       run_verse_test "Very Large Chapter" "Genesis" "999999" "1" "Please enter the reference" false

     

       227
       227
       -
       run_verse_test "Very Large Verse" "Genesis" "1" "999999" "Please enter the reference" false

     

       228
       228
       -
       

     

       229
       229
       -
       # Test case sensitivity

     

       230
       230
       -
       run_verse_test "Lowercase Book" "genesis" "1" "1" "1 In the beginning God created the heaven and the earth." true

     

       231
       231
       -
       run_verse_test "Mixed Case Book" "GEnesis" "1" "1" "1 In the beginning God created the heaven and the earth." true

     

       232
       232
       -
       

     

       233
       233
       -
       # Test two-word books

     

       234
       234
       -
       run_verse_test "First Samuel" "First Samuel" "1" "1" "1 Now there was a certain man of Ramathaim-zophim, of mount Ephraim, and his name [was] Elkanah, the son of Jeroham, the son of Elihu, the son of Tohu, the son of Zuph, an Ephrathite:" true

     

       235
       235
       -
       run_verse_test "Second Kings" "Second Kings" "1" "1" "1 Then Moab rebelled against Israel after the death of Ahab" true

     

       236
       236
       -
       

     

       237
       237
       -
       # Appending Tests

     

       238
       238
       -
       print_section "Appending & File Path Tests"

     

       239
       239
       -
       

     

       240
       240
       -
       # Function to run appending test

     

       241
       241
       -
       run_appending_test() {

     

       242
       242
       -
           local test_name="$1"

     

       243
       243
       -
       

     

       244
       244
       -
           # Clean up previous test

     

       245
       245
       -
           rm -f "$output_file"

     

       246
       246
       -
       

     

       247
       247
       -
           # First verse lookup

     

       248
       248
       -
           input1="Genesis\n1\n1"

     

       249
       249
       -
           output1=$(timeout "$test_timeout" bash -c "echo -e '$input1' | '$program' OT.txt '$output_file'" 2>&1)

     

       250
       250
       -
           exit_code1=$?

     

       251
       251
       -
       

     

       252
       252
       -
           if [ $exit_code1 -ne 0 ]; then

     

       253
       253
       -
               print_result "$test_name - First Lookup" "FAIL" "First verse lookup failed"

     

       254
       254
       -
               return

     

       255
       255
       -
           fi

     

       256
       256
       -
       

     

       257
       257
       -
           # Check first verse was written

     

       258
       258
       -
           if [ ! -f "$output_file" ]; then

     

       259
       259
       -
               print_result "$test_name - First File" "FAIL" "First verse file not created"

     

       260
       260
       -
               return

     

       261
       261
       -
           fi

     

       262
       262
       -
       

     

       263
       263
       -
           first_content=$(cat "$output_file")

     

       264
       264
       -
       

     

       265
       265
       -
           # Second verse lookup

     

       266
       266
       -
           input2="Genesis\n1\n2"

     

       267
       267
       -
           output2=$(timeout "$test_timeout" bash -c "echo -e '$input2' | '$program' OT.txt '$output_file'" 2>&1)

     

       268
       268
       -
           exit_code2=$?

     

       269
       269
       -
       

     

       270
       270
       -
           if [ $exit_code2 -ne 0 ]; then

     

       271
       271
       -
               print_result "$test_name - Second Lookup" "FAIL" "Second verse lookup failed"

     

       272
       272
       -
               return

     

       273
       273
       -
           fi

     

       274
       274
       -
       

     

       275
       275
       -
           # Check if file still exists and has content

     

       276
       276
       -
           if [ ! -f "$output_file" ]; then

     

       277
       277
       -
               print_result "$test_name - Second File" "FAIL" "File disappeared after second lookup"

     

       278
       278
       -
               return

     

       279
       279
       -
           fi

     

       280
       280
       -
       

     

       281
       281
       -
           second_content=$(cat "$output_file")

     

       282
       282
       -
       

     

       283
       283
       -
           # Check if both verses are in the file (appending behavior)

     

       284
       284
       -
           if [[ "$second_content" == *"1 In the beginning God created the heaven and the earth"* ]] && [[ "$second_content" == *"2 And the earth was without form, and void"* ]]; then

     

       285
       285
       -
               print_result "$test_name" "PASS" "Both verses found in file (appending works)"

     

       286
       286
       -
           elif [[ "$second_content" == *"2 And the earth was without form, and void"* ]] && [[ "$second_content" != *"1 In the beginning God created the heaven and the earth"* ]]; then

     

       287
       287
       -
               print_result "$test_name" "FAIL" "Only second verse found (overwriting instead of appending)"

     

       288
       288
       -
           else

     

       289
       289
       -
               print_result "$test_name" "FAIL" "Unexpected file content after second lookup"

     

       290
       290
       -
           fi

     

       291
       291
       -
       }

     

       292
       292
       -
       

     

       293
       293
       -
       run_appending_test "Multiple Verse Appending"

     

       294
       294
       -
       

     

       295
       295
       -
       # Function to run file path test

     

       296
       296
       -
       run_file_path_test() {

     

       297
       297
       -
           local test_name="$1"

     

       298
       298
       -
           local file_path="$2"

     

       299
       299
       -
           local expected_pattern="$3"

     

       300
       300
       -
           local should_succeed="$4"

     

       301
       301
       -
       

     

       302
       302
       -
           # Clean up previous test

     

       303
       303
       -
           rm -f "$output_file"

     

       304
       304
       -
       

     

       305
       305
       -
           # Provide verse lookup input for file path tests

     

       306
       306
       -
           input="Genesis\n1\n1"

     

       307
       307
       -
       

     

       308
       308
       -
           if [ -n "$file_path" ]; then

     

       309
       309
       -
               output=$(timeout "$test_timeout" bash -c "echo -e '$input' | '$program' '$file_path' '$output_file'" 2>&1)

     

       310
       310
       -
           else

     

       311
       311
       -
               output=$(timeout "$test_timeout" bash -c "echo -e '$input' | '$program' OT.txt '$output_file'" 2>&1)

     

       312
       312
       -
           fi

     

       313
       313
       -
           exit_code=$?

     

       314
       314
       -
       

     

       315
       315
       -
           if [ $exit_code -eq 124 ]; then

     

       316
       316
       -
               print_result "$test_name" "TIMEOUT" "Program timed out after ${test_timeout}s"

     

       317
       317
       -
               return

     

       318
       318
       -
           fi

     

       319
       319
       -
       

     

       320
       320
       -
           if [ "$should_succeed" = "true" ]; then

     

       321
       321
       -
               if [ $exit_code -eq 0 ]; then

     

       322
       322
       -
                   print_result "$test_name" "PASS" "Program accepted file path successfully"

     

       323
       323
       -
               else

     

       324
       324
       -
                   print_result "$test_name" "FAIL" "Program failed with exit code $exit_code: $output"

     

       325
       325
       -
               fi

     

       326
       326
       -
           else

     

       327
       327
       -
               if [ $exit_code -ne 0 ] && [[ "$output" == *"$expected_pattern"* ]]; then

     

       328
       328
       -
                   print_result "$test_name" "PASS" "Program correctly rejected invalid file path"

     

       329
       329
       -
               elif [ $exit_code -eq 0 ]; then

     

       330
       330
       -
                   print_result "$test_name" "FAIL" "Program should have failed with invalid file path"

     

       331
       331
       -
               else

     

       332
       332
       -
                   print_result "$test_name" "FAIL" "Expected error message '$expected_pattern' not found: $output"

     

       333
       333
       -
               fi

     

       334
       334
       -
           fi

     

       335
       335
       -
       }

     

       336
       336
       -
       

     

       337
       337
       -
       # Test with existing file (absolute path)

     

       338
       338
       -
       run_file_path_test "Existing File (Absolute)" "/Users/kierank/code/school/lab-6/test/OT.txt" "" true

     

       339
       339
       -
       

     

       340
       340
       -
       # Test with existing file (relative path)

     

       341
       341
       -
       run_file_path_test "Existing File (Relative)" "OT.txt" "" true

     

       342
       342
       -
       

     

       343
       343
       -
       # Test with non-existing file

     

       344
       344
       -
       run_file_path_test "Non-existing File" "nonexistent.txt" "failed to open file" false

     

       345
       345
       -
       

     

       346
       346
       -
       # Test with invalid path

     

       347
       347
       -
       run_file_path_test "Invalid Path" "/invalid/path/file.txt" "failed to open file" false

     

       348
       348
       -
       

     

       349
       349
       -
       # Test with empty path

     

       350
       350
       -
       run_file_path_test "Empty Path" "" "" true

     

       351
       351
       -
       

     

       352
       352
       -
       # Test summary

     

       353
       353
       -
       print_section "Test Summary"

     

       354
       354
       -
       echo -e "${BLUE}Tests passed: $passed_tests/$total_tests${NC}"

     

       355
       355
       -
       

     

       356
       356
       -
       if [ $passed_tests -eq $total_tests ]; then

     

       357
       357
       -
           echo -e "${GREEN}All tests passed!${NC}"

     

       358
       358
       -
           exit 0

     

       359
       359
       -
       else

     

       360
       360
       -
           echo -e "${RED}Some tests failed!${NC}"

     

       361
       361
       -
           exit 1

     

       362
       362
       -
       fi