#!/bin/bash
######################################################################################
#
# This script is used for testing the assert command from outside the Shell.
#
# Issue:  NXM-4107 nm assert from os prompt needs to be tested
# Since:  NeXtMidas 4.1.4
# Author: Zachary Matthews
#
######################################################################################

# Check if NMROOT is defined
if [[ -z "${NMROOT}" ]]; then
  echo "WARNING: NMROOT is not defined"
  exit 1
fi

# Check if JAVAHOME is defined
if [[ -z "${JAVA_HOME}" ]]; then
  echo "WARNING: JAVA_HOME is not defined"
  exit 1
fi

# Start new NeXtMidas session
source ${NMROOT}/os/unix/nmstart.sh
echo ""

# Define results to be used in assert tests
source ${NMROOT}/os/unix/nm.sh res allLower \"abc\"
source ${NMROOT}/os/unix/nm.sh res allUpper \"ABC\"
source ${NMROOT}/os/unix/nm.sh res mixed    \"AbC\"

##############################################################################
# Run tests
##############################################################################

# Run tests for escaped quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to lower case with escaped quotes should match\"     \"abc\" eqs  \"abc\" /stat=lcetolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to upper case with escaped quotes should not match\" \"abc\" neqs \"ABC\" /stat=lcetouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to lower case with escaped quotes should not match\" \"ABC\" neqs \"abc\" /stat=ucetolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to upper case with escaped quotes should match\"     \"ABC\" eqs  \"ABC\" /stat=ucetouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to lower case with escaped quotes should not match\" \"AbC\" neqs \"abc\" /stat=mcetolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to upper case with escaped quotes should not match\" \"AbC\" neqs \"ABC\" /stat=mcetouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to mixed case with escaped quotes should match\"     \"AbC\" eqs  \"AbC\" /stat=mcetomce

# Run tests for escaped quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to lower case with no quotes should match\"     \"abc\" eqs  abc /stat=lcetolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to upper case with no quotes should not match\" \"abc\" neqs ABC /stat=lcetoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to lower case with no quotes should not match\" \"ABC\" neqs abc /stat=ucetolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to upper case with no quotes should match\"     \"ABC\" eqs  ABC /stat=ucetoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to lower case with no quotes should not match\" \"AbC\" neqs abc /stat=mcetolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to upper case with no quotes should not match\" \"AbC\" neqs ABC /stat=mcetoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to mixed case with no quotes should match\"     \"AbC\" eqs  AbC /stat=mcetomcn

# Run tests for escaped quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to lower case with regular quotes should match\"     \"abc\" eqs  "abc" /stat=lcetolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to upper case with regular quotes should not match\" \"abc\" neqs "ABC" /stat=lcetoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to lower case with regular quotes should not match\" \"ABC\" neqs "abc" /stat=ucetolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to upper case with regular quotes should match\"     \"ABC\" eqs  "ABC" /stat=ucetoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to lower case with regular quotes should not match\" \"AbC\" neqs "abc" /stat=mcetolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to upper case with regular quotes should not match\" \"AbC\" neqs "ABC" /stat=mcetoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to mixed case with regular quotes should match\"     \"AbC\" eqs  "AbC" /stat=mcetomcq

# Run tests for escaped quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to lower case with result should match\"     \"abc\" eqs  allLower /stat=lcetolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with escaped quotes to upper case with result should not match\" \"abc\" neqs allUpper /stat=lcetoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to lower case with result should not match\" \"ABC\" neqs allLower /stat=ucetolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with escaped quotes to upper case with result should match\"     \"ABC\" eqs  allUpper /stat=ucetoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to lower case with result should not match\" \"AbC\" neqs allLower /stat=mcetolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to upper case with result should not match\" \"AbC\" neqs allUpper /stat=mcetoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with escaped quotes to mixed case with result should match\"     \"AbC\" eqs  mixed    /stat=mcetomcr

# Run tests for no quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to lower case with escaped quotes should match\"     abc eqs  \"abc\" /stat=lcntolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to upper case with escaped quotes should not match\" abc neqs \"ABC\" /stat=lcntouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to lower case with escaped quotes should not match\" ABC neqs \"abc\" /stat=ucntolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to upper case with escaped quotes should match\"     ABC eqs  \"ABC\" /stat=ucntouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to lower case with escaped quotes should not match\" AbC neqs \"abc\" /stat=mcntolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to upper case with escaped quotes should not match\" AbC neqs \"ABC\" /stat=mcntouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to mixed case with escaped quotes should match\"     AbC eqs  \"AbC\" /stat=mcntomce

# Run tests for no quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to lower case with no quotes should match\"     abc eqs  abc /stat=lcntolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to upper case with no quotes should not match\" abc neqs ABC /stat=lcntoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to lower case with no quotes should not match\" ABC neqs abc /stat=ucntolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to upper case with no quotes should match\"     ABC eqs  ABC /stat=ucntoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to lower case with no quotes should not match\" AbC neqs abc /stat=mcntolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to upper case with no quotes should not match\" AbC neqs ABC /stat=mcntoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to mixed case with no quotes should match\"     AbC eqs  AbC /stat=mcntomcn

# Run tests for no quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to lower case with regular quotes should match\"     abc eqs  "abc" /stat=lcntolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to upper case with regular quotes should not match\" abc neqs "ABC" /stat=lcntoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to lower case with regular quotes should not match\" ABC neqs "abc" /stat=ucntolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to upper case with regular quotes should match\"     ABC eqs  "ABC" /stat=ucntoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to lower case with regular quotes should not match\" AbC neqs "abc" /stat=mcntolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to upper case with regular quotes should not match\" AbC neqs "ABC" /stat=mcntoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to mixed case with regular quotes should match\"     AbC eqs  "AbC" /stat=mcntomcq

# Run tests for no quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to lower case with result should match\"     abc eqs  allLower /stat=lcntolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with no quotes to upper case with result should not match\" abc neqs allUpper /stat=lcntoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to lower case with result should not match\" ABC neqs allLower /stat=ucntolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with no quotes to upper case with result should match\"     ABC eqs  allUpper /stat=ucntoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to lower case with result should not match\" AbC neqs allLower /stat=mcntolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to upper case with result should not match\" AbC neqs allUpper /stat=mcntoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with no quotes to mixed case with result should match\"     AbC eqs  mixed    /stat=mcntomcr

# Run tests for regular quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to lower case with escaped quotes should match\"     "abc" eqs  \"abc\" /stat=lcqtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to upper case with escaped quotes should not match\" "abc" neqs \"ABC\" /stat=lcqtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to lower case with escaped quotes should not match\" "ABC" neqs \"abc\" /stat=ucqtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to upper case with escaped quotes should match\"     "ABC" eqs  \"ABC\" /stat=ucqtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to lower case with escaped quotes should not match\" "AbC" neqs \"abc\" /stat=mcqtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to upper case with escaped quotes should not match\" "AbC" neqs \"ABC\" /stat=mcqtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to mixed case with escaped quotes should match\"     "AbC" eqs  \"AbC\" /stat=mcqtomce

# Run tests for regular quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to lower case with no quotes should match\"     "abc" eqs  abc /stat=lcqtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to upper case with no quotes should not match\" "abc" neqs ABC /stat=lcqtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to lower case with no quotes should not match\" "ABC" neqs abc /stat=ucqtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to upper case with no quotes should match\"     "ABC" eqs  ABC /stat=ucqtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to lower case with no quotes should not match\" "AbC" neqs abc /stat=mcqtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to upper case with no quotes should not match\" "AbC" neqs ABC /stat=mcqtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to mixed case with no quotes should match\"     "AbC" eqs  AbC /stat=mcqtomcn

# Run tests for regular quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to lower case with regular quotes should match\"     "abc" eqs  "abc" /stat=lcqtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to upper case with regular quotes should not match\" "abc" neqs "ABC" /stat=lcqtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to lower case with regular quotes should not match\" "ABC" neqs "abc" /stat=ucqtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to upper case with regular quotes should match\"     "ABC" eqs  "ABC" /stat=ucqtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to lower case with regular quotes should not match\" "AbC" neqs "abc" /stat=mcqtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to upper case with regular quotes should not match\" "AbC" neqs "ABC" /stat=mcqtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to mixed case with regular quotes should match\"     "AbC" eqs  "AbC" /stat=mcqtomcq

# Run tests for regular quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to lower case with result should match\"     "abc" eqs  allLower /stat=lcqtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with regular quotes to upper case with result should not match\" "abc" neqs allUpper /stat=lcqtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to lower case with result should not match\" "ABC" neqs allLower /stat=ucqtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with regular quotes to upper case with result should match\"     "ABC" eqs  allUpper /stat=ucqtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to lower case with result should not match\" "AbC" neqs allLower /stat=mcqtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to upper case with result should not match\" "AbC" neqs allUpper /stat=mcqtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with regular quotes to mixed case with result should match\"     "AbC" eqs  mixed    /stat=mcqtomcr

# Run tests for result to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to lower case with escaped quotes should match\"     allLower eqs  \"abc\" /stat=lcrtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to upper case with escaped quotes should not match\" allLower neqs \"ABC\" /stat=lcrtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to lower case with escaped quotes should not match\" allUpper neqs \"abc\" /stat=ucrtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to upper case with escaped quotes should match\"     allUpper eqs  \"ABC\" /stat=ucrtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to lower case with escaped quotes should not match\" mixed    neqs \"abc\" /stat=mcrtolce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to upper case with escaped quotes should not match\" mixed    neqs \"ABC\" /stat=mcrtouce
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to mixed case with escaped quotes should match\"     mixed    eqs  \"AbC\" /stat=mcrtomce

# Run tests for result to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to lower case with no quotes should match\"     allLower eqs  abc /stat=lcrtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to upper case with no quotes should not match\" allLower neqs ABC /stat=lcrtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to lower case with no quotes should not match\" allUpper neqs abc /stat=ucrtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to upper case with no quotes should match\"     allUpper eqs  ABC /stat=ucrtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to lower case with no quotes should not match\" mixed    neqs abc /stat=mcrtolcn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to upper case with no quotes should not match\" mixed    neqs ABC /stat=mcrtoucn
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to mixed case with no quotes should match\"     mixed    eqs  AbC /stat=mcrtomcn

# Run tests for result to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to lower case with regular quotes should match\"     allLower eqs  "abc" /stat=lcrtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to upper case with regular quotes should not match\" allLower neqs "ABC" /stat=lcrtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to lower case with regular quotes should not match\" allUpper neqs "abc" /stat=ucrtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to upper case with regular quotes should match\"     allUpper eqs  "ABC" /stat=ucrtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to lower case with regular quotes should not match\" mixed    neqs "abc" /stat=mcrtolcq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to upper case with regular quotes should not match\" mixed    neqs "ABC" /stat=mcrtoucq
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to mixed case with regular quotes should match\"     mixed    eqs  "AbC" /stat=mcrtomcq

# Run tests for result to result
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to lower case with result should match\"     allLower eqs  allLower /stat=lcrtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Lower case with result to upper case with result should not match\" allLower neqs allUpper /stat=lcrtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to lower case with result should not match\" allUpper neqs allLower /stat=ucrtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Upper case with result to upper case with result should match\"     allUpper eqs  allUpper /stat=ucrtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to lower case with result should not match\" mixed    neqs allLower /stat=mcrtolcr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to upper case with result should not match\" mixed    neqs allUpper /stat=mcrtoucr
source ${NMROOT}/os/unix/nm.sh assert/cs/debug=false/hidefail/text=\"CS Mixed case with result to mixed case with result should match\"     mixed    eqs  mixed    /stat=mcrtomcr

##############################################################################
# Check test results
##############################################################################

# Check test results for escaped quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to lower case with escaped quotes\" lcetolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to upper case with escaped quotes\" lcetouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to lower case with escaped quotes\" ucetolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to upper case with escaped quotes\" ucetouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to lower case with escaped quotes\" mcetolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to upper case with escaped quotes\" mcetouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to mixed case with escaped quotes\" mcetomce eqs "PASS"

# Check test results for escaped quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to lower case with no quotes\" lcetolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to upper case with no quotes\" lcetoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to lower case with no quotes\" ucetolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to upper case with no quotes\" ucetoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to lower case with no quotes\" mcetolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to upper case with no quotes\" mcetoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to mixed case with no quotes\" mcetomcn eqs "PASS"

# Check test results for escaped quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to lower case with regular quotes\" lcetolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to upper case with regular quotes\" lcetoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to lower case with regular quotes\" ucetolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to upper case with regular quotes\" ucetoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to lower case with regular quotes\" mcetolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to upper case with regular quotes\" mcetoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to mixed case with regular quotes\" mcetomcq eqs "PASS"

# Check test results for escaped quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to lower case with result\" lcetolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with escaped quotes to upper case with result\" lcetoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to lower case with result\" ucetolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with escaped quotes to upper case with result\" ucetoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to lower case with result\" mcetolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to upper case with result\" mcetoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with escaped quotes to mixed case with result\" mcetomcr eqs "PASS"

# Check test results for no quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to lower case with escaped quotes\" lcntolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to upper case with escaped quotes\" lcntouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to lower case with escaped quotes\" ucntolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to upper case with escaped quotes\" ucntouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to lower case with escaped quotes\" mcntolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to upper case with escaped quotes\" mcntouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to mixed case with escaped quotes\" mcntomce eqs "PASS"

# Check test results for no quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to lower case with no quotes\" lcntolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to upper case with no quotes\" lcntoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to lower case with no quotes\" ucntolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to upper case with no quotes\" ucntoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to lower case with no quotes\" mcntolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to upper case with no quotes\" mcntoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to mixed case with no quotes\" mcntomcn eqs "PASS"

# Check test results for no quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to lower case with regular quotes\" lcntolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to upper case with regular quotes\" lcntoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to lower case with regular quotes\" ucntolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to upper case with regular quotes\" ucntoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to lower case with regular quotes\" mcntolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to upper case with regular quotes\" mcntoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to mixed case with regular quotes\" mcntomcq eqs "PASS"

# Check test results for no quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to lower case with result\" lcntolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with no quotes to upper case with result\" lcntoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to lower case with result\" ucntolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with no quotes to upper case with result\" ucntoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to lower case with result\" mcntolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to upper case with result\" mcntoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with no quotes to mixed case with result\" mcntomcr eqs "PASS"

# Check test results for regular quotes to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to lower case with escaped quotes\" lcqtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to upper case with escaped quotes\" lcqtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to lower case with escaped quotes\" ucqtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to upper case with escaped quotes\" ucqtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to lower case with escaped quotes\" mcqtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to upper case with escaped quotes\" mcqtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to mixed case with escaped quotes\" mcqtomce eqs "PASS"

# Check test results for regular quotes to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to lower case with no quotes\" lcqtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to upper case with no quotes\" lcqtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to lower case with no quotes\" ucqtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to upper case with no quotes\" ucqtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to lower case with no quotes\" mcqtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to upper case with no quotes\" mcqtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to mixed case with no quotes\" mcqtomcn eqs "PASS"

# Check test results for regular quotes to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to lower case with regular quotes\" lcqtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to upper case with regular quotes\" lcqtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to lower case with regular quotes\" ucqtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to upper case with regular quotes\" ucqtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to lower case with regular quotes\" mcqtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to upper case with regular quotes\" mcqtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to mixed case with regular quotes\" mcqtomcq eqs "PASS"

# Check test results for regular quotes to result
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to lower case with result\" lcqtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with regular quotes to upper case with result\" lcqtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to lower case with result\" ucqtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with regular quotes to upper case with result\" ucqtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to lower case with result\" mcqtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to upper case with result\" mcqtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with regular quotes to mixed case with result\" mcqtomcr eqs "PASS"

# Check test results for result to escaped quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to lower case with escaped quotes\" lcrtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to upper case with escaped quotes\" lcrtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to lower case with escaped quotes\" ucrtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to upper case with escaped quotes\" ucrtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to lower case with escaped quotes\" mcrtolce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to upper case with escaped quotes\" mcrtouce eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to mixed case with escaped quotes\" mcrtomce eqs "PASS"

# Check test results for result to no quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to lower case with no quotes\" lcrtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to upper case with no quotes\" lcrtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to lower case with no quotes\" ucrtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to upper case with no quotes\" ucrtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to lower case with no quotes\" mcrtolcn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to upper case with no quotes\" mcrtoucn eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to mixed case with no quotes\" mcrtomcn eqs "PASS"

# Check test results for result to regular quotes
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to lower case with regular quotes\" lcrtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to upper case with regular quotes\" lcrtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to lower case with regular quotes\" ucrtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to upper case with regular quotes\" ucrtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to lower case with regular quotes\" mcrtolcq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to upper case with regular quotes\" mcrtoucq eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to mixed case with regular quotes\" mcrtomcq eqs "PASS"

# Check test results for result to result
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to lower case with result\" lcrtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= lower case with result to upper case with result\" lcrtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to lower case with result\" ucrtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= upper case with result to upper case with result\" ucrtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to lower case with result\" mcrtolcr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to upper case with result\" mcrtoucr eqs "PASS"
source ${NMROOT}/os/unix/nm.sh assert/cs/text=\"CS check /STAT= mixed case with result to mixed case with result\" mcrtomcr eqs "PASS"

source ${NMROOT}/os/unix/nmend.sh
