Adds other tests for ZObject

Implements directly inside ZObject GetDefaultProperty. Little fix to GetPropertyAddr when retrieving the first property address. Creates facility(but badly implemented) for getting property ids in sorted order.

Author: danieledapo

gork/zmachine.go

@@ -209,17 +209,6 @@ func (zm *ZMachine) ResetObjectParent(objectId uint8, newParentId uint8) {
 zm.objects[objectId-1].parent = newParentId
 }
 
-func (zm *ZMachine) GetDefaultProperty(propertyIdx byte) uint16 {
-// v3
-if propertyIdx < 1 || propertyIdx > 31 {
-log.Fatalf("Invalid propertyIndex %d, values range in v3 is [1,31]\n", propertyIdx)
-}
-
-// property table is a sequence of words
-addr := uint32(zm.header.objTblPos) + uint32((propertyIdx-1)*2)
-return zm.seq.mem.WordAt(addr)
-}
-
 func (zm *ZMachine) InterpretAll() {
 for !zm.quitted {
 zm.Interpret()

gork/zobject.go

@@ -1,7 +1,6 @@
 package gork
 
 import (
-"errors"
 "fmt"
 "log"
 "sort"
@@ -24,6 +23,7 @@ type ZObject struct {
 propertiesPos uint16
 properties map[byte][]byte
 mem *ZMemory
+header *ZHeader
 }
 
 func NewZObject(mem *ZMemory, number uint8, header *ZHeader) *ZObject {
@@ -36,6 +36,7 @@ func (obj *ZObject) configure(mem *ZMemory, number uint8, header *ZHeader) {
 obj.number = number
 
 obj.mem = mem
+obj.header = header
 
 seq := mem.GetSequential(ZObjectAddress(number, header))
 
@@ -121,11 +122,19 @@ func (obj *ZObject) SetProperty(propertyId byte, value uint16) {
 }
 }
 
-func (obj *ZObject) GetProperty(propertyId byte) (uint16, error) {
+func (obj *ZObject) GetProperty(propertyId byte) uint16 {
 if _, ok := obj.properties[propertyId]; !ok {
 // DON'T PANIC, cause the property could be in the
 // global default properties table
-return 0, errors.New(fmt.Sprintf("property %d not found\n", propertyId))
+
+// v3
+if propertyId < 1 || propertyId > 31 {
+log.Fatalf("Invalid propertyIndex %d, values range in v3 is [1,31]\n", propertyId)
+}
+
+// property table is a sequence of words
+addr := uint32(obj.header.objTblPos) + uint32((propertyId-1)*2)
+return obj.mem.WordAt(addr)
 }
 
 res := uint16(0)
@@ -142,7 +151,7 @@ func (obj *ZObject) GetProperty(propertyId byte) (uint16, error) {
 log.Fatal("cannot get property, because its length is > 2 bytes")
 }
 
-return res, nil
+return res
 }
 
 func GetPropertyLen(mem *ZMemory, propertyPos uint32) uint16 {
@@ -164,7 +173,6 @@ func (obj *ZObject) GetPropertyAddr(propertyId byte) uint32 {
 
 for {
 size := obj.mem.ByteAt(addr)
-addr++
 
 propno := size & 0x1F
 
@@ -177,6 +185,9 @@ func (obj *ZObject) GetPropertyAddr(propertyId byte) uint32 {
 if propno == propertyId {
 return addr
 }
+// skip size
+addr++
+
 addr += uint32((size >> 5) + 1)
 }
 }
@@ -229,6 +240,22 @@ func ZObjectsCount(mem *ZMemory, header *ZHeader) uint8 {
 return count - 1
 }
 
+func (obj *ZObject) PropertiesIds() []byte {
+var keys []int
+for k := range obj.properties {
+keys = append(keys, int(k))
+}
+sort.Sort(sort.Reverse(sort.IntSlice(keys)))
+
+ret := make([]byte, len(keys))
+
+for i, v := range keys {
+ret[i] = byte(v)
+}
+
+return ret
+}
+
 func (obj *ZObject) String() string {
 ret := ""
 
@@ -255,16 +282,10 @@ func (obj *ZObject) String() string {
 
 ret += fmt.Sprintln(" Properties:")
 
-var keys []int
-for k := range obj.properties {
-keys = append(keys, int(k))
-}
-sort.Sort(sort.Reverse(sort.IntSlice(keys)))
-
-for _, k := range keys {
+for _, k := range obj.PropertiesIds() {
 ret += fmt.Sprintf(" [%2d] ", k)
-for b := range obj.properties[byte(k)] {
-ret += fmt.Sprintf("%02X ", obj.properties[byte(k)][b])
+for b := range obj.properties[k] {
+ret += fmt.Sprintf("%02X ", obj.properties[k][b])
 }
 ret += fmt.Sprintln("")
 }

gork/zobject_test.go

@@ -1,6 +1,9 @@
 package gork
 
-import "testing"
+import (
+"encoding/binary"
+"testing"
+)
 
 // attributes, parent, sibling, child
 // DO NOT STORE propPos it will be calculated!
@@ -13,10 +16,13 @@ var zobjectData [][]byte = [][]byte{
 // nameLength, optional name, props
 var zobjectProps [][]byte = [][]byte{
 []byte{0x00, 0xB2, 0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4, 0x10, 0x82, 0x00},
-[]byte{0x04, 0x7E, 0x97, 0xC0, 0xA5, 0xB2, 0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4, 0x10, 0x82, 0x00},
-[]byte{0x04, 0x23, 0xC8, 0xC6, 0x95, 0xB2, 0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4, 0x00},
+[]byte{0x02, 0x7E, 0x97, 0xC0, 0xA5, 0xB2, 0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4, 0x30, 0x82, 0x21, 0x00},
+[]byte{0x02, 0x23, 0xC8, 0xC6, 0x95, 0xB2, 0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4, 0x00},
 }
 
+const defaultPropByte byte = 0xFF
+const defaultPropWord uint16 = uint16(defaultPropByte)<<8 | uint16(defaultPropByte)
+
 // TODO generate automatically propertiesPos
 var zobjectExpected []ZObject = []ZObject{
 ZObject{
@@ -42,7 +48,7 @@ var zobjectExpected []ZObject = []ZObject{
 propertiesPos: 0x0064,
 properties: map[byte][]byte{
 18: []byte{0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4},
-16: []byte{0x82},
+16: []byte{0x82, 0x21},
 },
 },
 ZObject{
@@ -52,7 +58,7 @@ var zobjectExpected []ZObject = []ZObject{
 sibling: 2,
 child: 0,
 name: "cyclop",
-propertiesPos: 0x0073,
+propertiesPos: 0x0074,
 properties: map[byte][]byte{
 18: []byte{0x46, 0xDC, 0x42, 0xC2, 0x42, 0xB4},
 },
@@ -75,8 +81,8 @@ func createZObjectBuf() []byte {
 ret := make([]byte, 31*2)
 
 for i := range ret {
-// default properties are all 0s in this case
-ret[i] = 0x00
+// default properties are all 0xFFs in this case
+ret[i] = defaultPropByte
 }
 
 firstPropPos := uint16(len(ret)) + uint16(len(zobjectData))*uint16(zobjectSize)
@@ -97,17 +103,28 @@ func createZObjectBuf() []byte {
 return ret
 }
 
-func TestZObject(t *testing.T) {
+func prelude() (*ZMemory, *ZHeader, uint8) {
 mem := ZMemory(createZObjectBuf())
 header := &ZHeader{objTblPos: 0x00}
 
 count := ZObjectsCount(&mem, header)
+
+return &mem, header, count
+}
+
+func TestZObjectCount(t *testing.T) {
+_, _, count := prelude()
+
 if count != uint8(len(zobjectExpected)) {
 t.Fail()
 }
+}
+
+func TestZObject(t *testing.T) {
+mem, header, count := prelude()
 
 for i := uint8(0); i < count; i++ {
-obj := NewZObject(&mem, i+1, header)
+obj := NewZObject(mem, i+1, header)
 expected := zobjectExpected[i]
 
 if obj.number != expected.number ||
@@ -117,7 +134,7 @@ func TestZObject(t *testing.T) {
 obj.child != expected.child ||
 obj.name != expected.name ||
 obj.propertiesPos != expected.propertiesPos ||
-obj.mem != &mem {
+obj.mem != mem {
 t.Fail()
 }
 
@@ -145,6 +162,152 @@ func TestZObject(t *testing.T) {
 }
 }
 
+func TestZObjectGetProperty(t *testing.T) {
+mem, header, count := prelude()
+
+for i := byte(0); i < count; i++ {
+obj := NewZObject(mem, i+1, header)
+good := zobjectExpected[i]
+
+for key, prop := range good.properties {
+if len(prop) <= 2 {
+rProp := obj.GetProperty(key)
+
+if len(prop) == 1 {
+if rProp != uint16(prop[0]) {
+t.Fail()
+}
+} else if rProp != binary.BigEndian.Uint16(prop) {
+t.Fail()
+}
+}
+}
+
+// should return default property
+if _, ok := obj.properties[31]; !ok && obj.GetProperty(31) != defaultPropWord {
+t.Fail()
+}
+}
+}
+
+func TestZObjectSetProperty(t *testing.T) {
+mem, header, count := prelude()
+
+for i := byte(0); i < count; i++ {
+obj := NewZObject(mem, i+1, header)
+
+var expected uint16
+
+for id, prop := range obj.properties {
+ok := true
+switch len(prop) {
+case 1:
+expected = uint16(defaultPropByte)
+case 2:
+expected = defaultPropWord
+default:
+ok = false
+}
+
+if ok {
+obj.SetProperty(id, expected)
+if obj.GetProperty(id) != expected {
+t.Fail()
+}
+}
+}
+}
+}
+
+func TestZObjectPropertyLen(t *testing.T) {
+mem, header, count := prelude()
+
+for i := byte(0); i < count; i++ {
+obj := NewZObject(mem, i+1, header)
+
+seq := mem.GetSequential(uint32(obj.propertiesPos))
+if seq.ReadByte() != 0 {
+// skip name
+seq.DecodeZString(header)
+}
+// skip dataSize
+seq.ReadByte()
+
+propertyPos := uint16(seq.pos)
+
+for _, k := range obj.PropertiesIds() {
+prop := obj.properties[k]
+
+if GetPropertyLen(mem, uint32(propertyPos)) != uint16(len(prop)) {
+t.Fail()
+}
+
+// skip propData and next dataSize
+propertyPos += uint16(len(prop)) + 1
+}
+}
+}
+
+func TestZObjectGetFirstPropertyAddr(t *testing.T) {
+mem, header, count := prelude()
+
+for i := byte(0); i < count; i++ {
+obj := NewZObject(mem, i+1, header)
+
+seq := mem.GetSequential(uint32(obj.propertiesPos))
+
+if seq.ReadByte() != 0 {
+// skip name
+seq.DecodeZString(header)
+}
+
+if obj.GetFirstPropertyAddr() != seq.pos {
+t.Fail()
+}
+}
+}
+
+func TestZObjectGetPropertyAddr(t *testing.T) {
+mem, header, count := prelude()
+
+for i := byte(0); i < count; i++ {
+obj := NewZObject(mem, i+1, header)
+
+seq := mem.GetSequential(uint32(obj.propertiesPos))
+
+if seq.ReadByte() != 0 {
+// skip name
+seq.DecodeZString(header)
+}
+propPos := seq.pos
+
+keys := obj.PropertiesIds()
+
+if len(keys) > 0 && obj.GetPropertyAddr(keys[0]) != obj.GetFirstPropertyAddr() {
+t.Fail()
+}
+
+// v3
+keyIdx := 0
+for propId := byte(31); propId > 0; propId-- {
+expected := uint32(0)
+if keyIdx < len(keys) && keys[keyIdx] == propId {
+expected = propPos
+keyIdx++
+
+// skip size
+propPos++
+propPos += uint32(len(zobjectExpected[i].properties[propId]))
+}
+
+if obj.GetPropertyAddr(byte(propId)) != expected {
+t.Fail()
+}
+
+}
+}
+}
+
 func TestZObjectId(t *testing.T) {
 header := &ZHeader{objTblPos: 0}
 for i := byte(0); i < 255; i++ {

gork/zoptable.go

@@ -318,13 +318,7 @@ func ZPutProp(zm *ZMachine, args []uint16) {
 }
 
 func ZGetProp(zm *ZMachine, objectId uint16, propertyId uint16) {
-res, err := zm.objects[objectId-1].GetProperty(byte(propertyId))
-
-if err != nil {
-// get default one
-res = zm.GetDefaultProperty(byte(propertyId))
-}
-
+res := zm.objects[objectId-1].GetProperty(byte(propertyId))
 zm.StoreReturn(res)
 }