gopher-lua/baselib_rawlen_test.go at master · Dronnis/gopher-lua · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package lua

import (
	"testing"
)

func TestRawLen(t *testing.T) {
	L := NewState()
	defer L.Close()

	// Тест: rawlen для строки
	if err := L.DoString(`result = rawlen("Hello")`); err != nil {
		t.Fatal(err)
	}
	result := int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 5 {
		t.Errorf("rawlen(\"Hello\") = %d, expected 5", result)
	}

	// Тест: rawlen для таблицы
	if err := L.DoString(`result = rawlen({1, 2, 3, 4, 5})`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 5 {
		t.Errorf("rawlen({1,2,3,4,5}) = %d, expected 5", result)
	}

	// Тест: rawlen для пустой таблицы
	if err := L.DoString(`result = rawlen({})`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 0 {
		t.Errorf("rawlen({}) = %d, expected 0", result)
	}

	// Тест: rawlen для таблицы с nil элементами
	if err := L.DoString(`t = {1, 2, nil, 4, 5}; result = rawlen(t)`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 5 {
		t.Errorf("rawlen({1, 2, nil, 4, 5}) = %d, expected 5", result)
	}

	// Тест: rawlen с метаметодом __len (должен игнорировать его)
	if err := L.DoString(`
		t = {1, 2, 3}
		mt = {__len = function() return 100 end}
		setmetatable(t, mt)
		result = rawlen(t)
	`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 3 {
		t.Errorf("rawlen with __len metamethod = %d, expected 3 (should ignore __len)", result)
	}

	// Тест: rawlen для пустой строки
	if err := L.DoString(`result = rawlen("")`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 0 {
		t.Errorf("rawlen(\"\") = %d, expected 0", result)
	}

	// Тест: rawlen для Unicode строки (длина в байтах)
	if err := L.DoString(`result = rawlen("Привет")`); err != nil {
		t.Fatal(err)
	}
	result = int(L.GetField(L.Get(EnvironIndex), "result").(LNumber).Int64())
	if result != 12 {
		t.Errorf("rawlen(\"Привет\") = %d, expected 12 (bytes)", result)
	}

	// Тест: rawlen для числа (должна быть ошибка)
	err := L.DoString(`result = rawlen(42)`)
	if err == nil {
		t.Error("rawlen(42) should return error")
	}

	// Тест: rawlen для nil (должна быть ошибка)
	err = L.DoString(`result = rawlen(nil)`)
	if err == nil {
		t.Error("rawlen(nil) should return error")
	}

	// Тест: rawlen для функции (должна быть ошибка)
	err = L.DoString(`result = rawlen(function() end)`)
	if err == nil {
		t.Error("rawlen(function) should return error")
	}
}

func TestRawLenVsLen(t *testing.T) {
	L := NewState()
	defer L.Close()

	// Тест: сравнение # и rawlen с метаметодом __len
	if err := L.DoString(`
		t = {1, 2, 3, 4, 5}
		mt = {__len = function() return 10 end}
		setmetatable(t, mt)
		raw = rawlen(t)
		meta = #t
	`); err != nil {
		t.Fatal(err)
	}

	raw := int(L.GetField(L.Get(EnvironIndex), "raw").(LNumber).Int64())
	meta := int(L.GetField(L.Get(EnvironIndex), "meta").(LNumber).Int64())

	if raw != 5 {
		t.Errorf("rawlen(t) = %d, expected 5", raw)
	}
	if meta != 10 {
		t.Errorf("#t with __len = %d, expected 10", meta)
	}
}