Implemented operators and better indexing

test/lsp_binary_test.go

@@ -0,0 +1,167 @@
+package integration
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLSPBinaryDiagnostics(t *testing.T) {
+	// 1. Build mdt
+	// Ensure we are in test directory context
+	buildCmd := exec.Command("go", "build", "-o", "../build/mdt", "../cmd/mdt")
+	if output, err := buildCmd.CombinedOutput(); err != nil {
+		t.Fatalf("Failed to build mdt: %v\nOutput: %s", err, output)
+	}
+
+	// 2. Start mdt lsp
+	cmd := exec.Command("../build/mdt", "lsp")
+	stdin, _ := cmd.StdinPipe()
+	stdout, _ := cmd.StdoutPipe()
+	stderr, _ := cmd.StderrPipe()
+	
+	// Pipe stderr to test log for debugging
+	go func() {
+		scanner := bufio.NewScanner(stderr)
+		for scanner.Scan() {
+			t.Logf("LSP STDERR: %s", scanner.Text())
+		}
+	}()
+
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("Failed to start mdt lsp: %v", err)
+	}
+	defer func() {
+		cmd.Process.Kill()
+		cmd.Wait()
+	}()
+
+	reader := bufio.NewReader(stdout)
+
+	send := func(m interface{}) {
+		body, _ := json.Marshal(m)
+		msg := fmt.Sprintf("Content-Length: %d\r\n\r\n%s", len(body), body)
+				stdin.Write([]byte(msg))
+			}
+		
+			readCh := make(chan map[string]interface{}, 100)
+		
+			go func() {		for {
+			// Parse Header
+			line, err := reader.ReadString('\n')
+			if err != nil {
+				close(readCh)
+				return
+			}
+			var length int
+			// Handle Content-Length: <len>\r\n
+			if _, err := fmt.Sscanf(strings.TrimSpace(line), "Content-Length: %d", &length); err != nil {
+				// Maybe empty line or other header?
+				continue
+			}
+			
+			// Read until empty line (\r\n)
+			for {
+				l, err := reader.ReadString('\n')
+				if err != nil {
+					close(readCh)
+					return
+				}
+				if l == "\r\n" {
+					break
+				}
+			}
+			
+			body := make([]byte, length)
+			if _, err := io.ReadFull(reader, body); err != nil {
+				close(readCh)
+				return
+			}
+			
+			var m map[string]interface{}
+			if err := json.Unmarshal(body, &m); err == nil {
+				readCh <- m
+			}
+		}
+	}()
+
+	cwd, _ := os.Getwd()
+	projectRoot := filepath.Dir(cwd)
+	absPath := filepath.Join(projectRoot, "examples/app_test.marte")
+	uri := "file://" + absPath
+
+	// 3. Initialize
+	examplesDir := filepath.Join(projectRoot, "examples")
+	send(map[string]interface{}{
+		"jsonrpc": "2.0",
+		"id":      1,
+		"method":  "initialize",
+		"params": map[string]interface{}{
+			"rootUri": "file://" + examplesDir,
+		},
+	})
+
+	// 4. Open app_test.marte
+	content, err := os.ReadFile(absPath)
+	if err != nil {
+		t.Fatalf("Failed to read test file: %v", err)
+	}
+	send(map[string]interface{}{
+		"jsonrpc": "2.0",
+		"method":  "textDocument/didOpen",
+		"params": map[string]interface{}{
+			"textDocument": map[string]interface{}{
+				"uri":        uri,
+				"languageId": "marte",
+				"version":    1,
+				"text":       string(content),
+			},
+		},
+	})
+
+	// 5. Wait for diagnostics
+	foundOrdering := false
+	foundVariable := false
+
+	timeout := time.After(30 * time.Second)
+	
+	for {
+		select {
+		case msg, ok := <-readCh:
+			if !ok {
+				t.Fatal("LSP stream closed unexpectedly")
+			}
+			t.Logf("Received: %v", msg)
+			if method, ok := msg["method"].(string); ok && method == "textDocument/publishDiagnostics" {
+				params := msg["params"].(map[string]interface{})
+				// Check URI match?
+				// if params["uri"] != uri { continue } // Might be absolute vs relative
+				
+diags := params["diagnostics"].([]interface{})
+				for _, d := range diags {
+					m := d.(map[string]interface{})["message"].(string)
+					if strings.Contains(m, "INOUT Signal 'A'") {
+						foundOrdering = true
+						t.Log("Found Ordering error")
+					}
+					if strings.Contains(m, "Unresolved variable reference: '$Value'") {
+						foundVariable = true
+						t.Log("Found Variable error")
+					}
+				}
+				if foundOrdering && foundVariable {
+					return // Success
+				}
+			}
+		case <-timeout:
+			t.Fatal("Timeout waiting for diagnostics")
+		}
+	}
+}