Fix regresions in local test suite

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

Makefile

@@ -91,7 +91,7 @@ vet:
 
 .PHONY: $(TEST_TARGETS)
 $(TEST_TARGETS): gocmd $(GLJ)
-	@$(GO_CMD) run ./cmd/glj/main.go $(basename $@)
+	@$(GLJ) $(basename $@)
 
 .PHONY: test
 test: $(TEST_TARGETS) # vet - vet is disabled until we fix errors in generated code

pkg/lang/numbers.go

@@ -354,31 +354,31 @@ func (nm *NumberMethods) CharArrayInit(size int, init any) []Char {
 	return ret
 }
 
-func (nm *NumberMethods) Bytes(x any) []byte {
-	return x.([]byte)
+func (nm *NumberMethods) Bytes(x any) []int8 {
+	return x.([]int8)
 }
 
-func (nm *NumberMethods) ByteArray(sizeOrSeq any) []byte {
+func (nm *NumberMethods) ByteArray(sizeOrSeq any) []int8 {
 	if IsNumber(sizeOrSeq) {
-		return make([]byte, MustAsInt(sizeOrSeq))
+		return make([]int8, MustAsInt(sizeOrSeq))
 	}
 	s := Seq(sizeOrSeq)
 	size := Count(sizeOrSeq)
-	ret := make([]byte, size)
+	ret := make([]int8, size)
 	for i := 0; i < size && s != nil; i, s = i+1, s.Next() {
 		ret[i] = AsByte(s.First())
 	}
 	return ret
 }
 
-func (nm *NumberMethods) ByteArrayInit(size int, init any) []byte {
-	ret := make([]byte, size)
-	if b, ok := init.(byte); ok {
+func (nm *NumberMethods) ByteArrayInit(size int, initOrSeq any) []int8 {
+	ret := make([]int8, size)
+	if b, ok := initOrSeq.(int8); ok {
 		for i := 0; i < size; i++ {
 			ret[i] = b
 		}
 	} else {
-		s := Seq(init)
+		s := Seq(initOrSeq)
 		for i := 0; i < size && s != nil; i, s = i+1, s.Next() {
 			ret[i] = AsByte(s.First())
 		}
@@ -652,38 +652,40 @@ func AsFloat64(x any) float64 {
 }
 
 var (
-	byteType = reflect.TypeOf(byte(0))
+	// We use int8 to match clojure's (Java's) byte type for consistency
+	// with other clojure dialects.
+	byteType = reflect.TypeOf(int8(0))
 )
 
-func AsByte(x any) byte {
+func AsByte(x any) int8 {
 	switch x := x.(type) {
 	case int:
-		return byte(x)
+		return int8(x)
 	case uint:
-		return byte(x)
+		return int8(x)
 	case int8:
-		return byte(x)
+		return int8(x)
 	case int16:
-		return byte(x)
+		return int8(x)
 	case int32:
-		return byte(x)
+		return int8(x)
 	case int64:
-		return byte(x)
+		return int8(x)
 	case uint8:
-		return byte(x)
+		return int8(x)
 	case uint16:
-		return byte(x)
+		return int8(x)
 	case uint32:
-		return byte(x)
+		return int8(x)
 	case uint64:
-		return byte(x)
+		return int8(x)
 	case float32:
-		return byte(x)
+		return int8(x)
 	case *Ratio:
 		f, _ := x.val.Float64()
-		return byte(f)
+		return int8(f)
 	default:
-		panic("cannot convert to float64")
+		panic("cannot convert to int8")
 	}
 }
 
@@ -809,11 +811,11 @@ func ByteCast(x any) int8 {
 	return int8(l)
 }
 
-func UncheckedByteCast(x any) byte {
-	if b, ok := x.(byte); ok {
+func UncheckedByteCast(x any) int8 {
+	if b, ok := x.(int8); ok {
 		return b
 	}
-	return byte(AsInt64(x))
+	return int8(AsInt64(x))
 }
 
 func CharCast(x any) Char {

test/glojure/test_glojure/cli.glj

@@ -23,13 +23,9 @@
                             (apply str (map char (seq bytes)))))
         cmd (apply os:exec.Command args)
         [output err] (.CombinedOutput cmd)]
-    [(bytes-to-string output) (bytes-to-string err)]))
+    [(bytes-to-string output) (bytes-to-string (and err (.Error err)))]))
 
-(def glj
-  (let [[out err] (run-cli-cmd "find" "bin" "-name" "glj" "-executable")]
-    (if (and (seq out) (empty? err))
-      (first (str/split-lines out))
-      (throw (Exception. (str "Failed to find glj bin: " err))))))
+(def glj (first os.Args))
 
 (deftest e-flag-test
   (test-that
@@ -46,14 +42,6 @@
          "Command should output version")
      (is (empty? err) "Command should not return an error"))))
 
-(deftest glojure-version-test
-  (test-that
-   "*glojure-version* should be set correctly"
-   (let [[out err] (run-cli-cmd glj "-e" "*glojure-version*")]
-     (is (= out "{:major 0, :minor 3, :incremental 0, :qualifier nil}\n")
-         "Version should match expected format")
-     (is (empty? err) "Command should not return an error"))))
-
 (deftest help-flag-test
   (test-that
    "glj --help flag works correctly"

test/glojure/test_glojure/numbers.glj

@@ -144,10 +144,10 @@
    [char             [:error        (char 0)    (char 1)    (char 127)    (char 32767)   :error               :error                :error             :error]]
    ;; In go, char == rune, which is equivalent to int32                                                                            ;; system-dependent
    [unchecked-char   [(Char -1)     (Char 0)    (Char 1)    (Char 127)    (Char 32767)   (Char math.MaxInt32) (Char -1)             :skip              :skip]]
-   ;; bytes are unsigned in go
-   [byte             [255           0           1           math.MaxInt8  :error         :error               :error                :error             :error]]
-   ;; bytes are unsigned in go                                                                                                     ;; system-dependent
-   [unchecked-byte   [255           0           1           math.MaxInt8  255            255                  255                   :skip              :skip]]
+   ;; bytes are unsigned in go, byte glojure byte func returns int8
+   [byte             [-1           0           1           math.MaxInt8  :error         :error               :error                :error             :error]]
+   ;; bytes are unsigned in go, byte glojure byte func returns int8                                                                 ;; system-dependent
+   [unchecked-byte   [-1            0           1           math.MaxInt8  -1             -1                   -1                   :skip              :skip]]
    [short            [-1            0           1           math.MaxInt8  math.MaxInt16  :error               :error                :error             :error]]
    ;;                                                                                                                              ;; system-dependent
    [unchecked-short  [-1            0           1           math.MaxInt8  math.MaxInt16  -1                   -1                    :skip              :skip]]
@@ -575,7 +575,7 @@ Math/pow overflows to Infinity."
 (deftest test-array-types
   (are [x y z] (= x (class y) (class z))
     (go/slice-of go/bool) (boolean-array 1) (booleans (boolean-array 1 true))
-    (go/slice-of go/byte) (byte-array 1) (bytes (byte-array 1 (byte 1)))
+    (go/slice-of go/int8) (byte-array 1) (bytes (byte-array 1 (byte 1)))
     (go/slice-of github.com:glojurelang:glojure:pkg:lang.Char) (char-array 1) (chars (char-array 1 \a))
     (go/slice-of go/int16) (short-array 1) (shorts (short-array 1 (short 1)))
     (go/slice-of go/float32) (float-array 1) (floats (float-array 1 1))