package processor

import (
	"strings"
	"testing"

	"regexp"

	"github.com/antchfx/xmlquery"
	lua "github.com/yuin/gopher-lua"
)

// Helper function to normalize whitespace for comparison
func normalizeXMLWhitespace(s string) string {
	// Replace all whitespace sequences with a single space
	re := regexp.MustCompile(`\s+`)
	s = re.ReplaceAllString(strings.TrimSpace(s), " ")

	// Normalize XML entities for comparison
	s = ConvertToNamedEntities(s)

	return s
}

func TestXMLProcessor_Process_NodeValues(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer's Guide</title>
    <genre>Computer</genre>
    <price>44.95</price>
    <publish_date>2000-10-01</publish_date>
    <description>An in-depth look at creating applications with XML.</description>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <genre>Fantasy</genre>
    <price>5.95</price>
    <publish_date>2000-12-16</publish_date>
    <description>A former architect battles corporate zombies.</description>
  </book>
</catalog>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer&apos;s Guide</title>
    <genre>Computer</genre>
    <price>89.9</price>
    <publish_date>2000-10-01</publish_date>
    <description>An in-depth look at creating applications with XML.</description>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <genre>Fantasy</genre>
    <price>11.9</price>
    <publish_date>2000-12-16</publish_date>
    <description>A former architect battles corporate zombies.</description>
  </book>
</catalog>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//price", "v.value = v.value * 2")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_Attributes(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<items>
  <item price="10.50" quantity="1">Widget A</item>
  <item price="5.25" quantity="3">Widget B</item>
</items>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<items>
  <item price="21" quantity="1">Widget A</item>
  <item price="10.5" quantity="3">Widget B</item>
</items>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//item/@price", "v.value = v.value * 2")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ElementText(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<names>
  <n>john</n>
  <n>mary</n>
</names>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<names>
  <n>JOHN</n>
  <n>MARY</n>
</names>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//n/text()", "v.value = string.upper(v.value)")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ElementAddition(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<config>
  <settings>
    <timeout>30</timeout>
    <max_connections>100</max_connections>
  </settings>
</config>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<config>
  <settings>
    <timeout>60</timeout>
    <max_connections>200</max_connections>
  </settings>
</config>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//settings/*", "v.value = v.value * 2")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ComplexXML(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<store>
  <department name="Electronics">
    <product id="p1" stock="50">
      <name>Laptop</name>
      <price currency="USD">999.99</price>
    </product>
    <product id="p2" stock="100">
      <name>Smartphone</name>
      <price currency="USD">499.99</price>
    </product>
  </department>
  <department name="Clothing">
    <product id="p3" stock="200">
      <name>T-Shirt</name>
      <price currency="USD">19.99</price>
    </product>
  </department>
</store>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<store>
  <department name="Electronics">
    <product id="p1" stock="50">
      <name>Laptop</name>
      <price currency="USD">1199.988</price>
    </product>
    <product id="p2" stock="100">
      <name>Smartphone</name>
      <price currency="USD">599.988</price>
    </product>
  </department>
  <department name="Clothing">
    <product id="p3" stock="200">
      <name>T-Shirt</name>
      <price currency="USD">23.988</price>
    </product>
  </department>
</store>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//price", "v.value = round(v.value * 1.2, 3)")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 3 {
		t.Errorf("Expected 3 matches, got %d", matchCount)
	}

	if modCount != 3 {
		t.Errorf("Expected 3 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

// New tests added below

func TestXMLProcessor_ConditionalModification(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<inventory>
  <item id="1" stock="5" price="10.00"/>
  <item id="2" stock="15" price="20.00"/>
  <item id="3" stock="0" price="15.00"/>
</inventory>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<inventory>
  <item id="1" stock="5" price="8.00"></item>
  <item id="2" stock="15" price="16.00"></item>
  <item id="3" stock="0" price="15.00"></item>
</inventory>`

	p := &XMLProcessor{}
	// Apply 20% discount but only for items with stock > 0
	luaExpr := `
	-- In the table-based approach, attributes are accessible directly
	if v.attr.stock and tonumber(v.attr.stock) > 0 then
		v.attr.price = tonumber(v.attr.price) * 0.8
		-- Format to 2 decimal places
		v.attr.price = string.format("%.2f", v.attr.price)
	else
		return false
	end
	`
	result, modCount, matchCount, err := p.ProcessContent(content, "//item", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 3 {
		t.Errorf("Expected 3 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_SpecialCharacters(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<data>
  <entry>This &amp; that</entry>
  <entry>a &lt; b</entry>
  <entry>c &gt; d</entry>
  <entry>Quote: &quot;Hello&quot;</entry>
</data>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<data>
  <entry>THIS &amp; THAT</entry>
  <entry>A &lt; B</entry>
  <entry>C &gt; D</entry>
  <entry>QUOTE: &quot;HELLO&quot;</entry>
</data>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//entry", "v.value = string.upper(v.value)")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 4 {
		t.Errorf("Expected 4 matches, got %d", matchCount)
	}

	if modCount != 4 {
		t.Errorf("Expected 4 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ChainedOperations(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<products>
  <product>
    <name>Widget</name>
    <price>100</price>
    <stock>20</stock>
  </product>
</products>`

	// Apply multiple operations to the price: add tax, apply discount, round
	luaExpr := `
	local price = v.value
	-- Add 15% tax
	price = price * 1.15
	-- Apply 10% discount
	price = price * 0.9
	-- Round to 2 decimal places
	price = round(price, 2)
	v.value = price
	`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<products>
  <product>
    <name>Widget</name>
    <price>103.5</price>
    <stock>20</stock>
  </product>
</products>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//price", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}

	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_MathFunctions(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<measurements>
  <measurement>3.14159</measurement>
  <measurement>2.71828</measurement>
  <measurement>1.41421</measurement>
</measurements>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<measurements>
  <measurement>3</measurement>
  <measurement>3</measurement>
  <measurement>1</measurement>
</measurements>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//measurement", "v.value = round(v.value)")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 3 {
		t.Errorf("Expected 3 matches, got %d", matchCount)
	}

	if modCount != 3 {
		t.Errorf("Expected 3 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_StringOperations(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<contacts>
  <contact>
    <name>John Doe</name>
    <email>john.doe@example.com</email>
    <phone>123-456-7890</phone>
  </contact>
</contacts>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<contacts>
  <contact>
    <name>John Doe</name>
    <email>johndoe@anon.com</email>
    <phone>123-XXX-XXXX</phone>
  </contact>
</contacts>`

	// Test email anonymization
	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//email", `
		-- With the table approach, v contains the text content directly
		v.value = string.gsub(v.value, "@.+", "@anon.com")
		local username = string.match(v.value, "(.+)@")
		v.value = string.gsub(username, "%.", "") .. "@anon.com"
	`)

	if err != nil {
		t.Fatalf("Error processing email content: %v", err)
	}

	// Test phone number masking
	result, modCount2, matchCount2, err := p.ProcessContent(result, "//phone", `
		v.value = string.gsub(v.value, "%d%d%d%-%d%d%d%-%d%d%d%d", function(match)
			return string.sub(match, 1, 3) .. "-XXX-XXXX"
		end)
	`)

	if err != nil {
		t.Fatalf("Error processing phone content: %v", err)
	}

	// Total counts from both operations
	matchCount += matchCount2
	modCount += modCount2

	if matchCount != 2 {
		t.Errorf("Expected 2 total matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 total modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_DateManipulation(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<events>
  <event>
    <name>Conference</name>
    <date>2023-06-15</date>
  </event>
  <event>
    <name>Workshop</name>
    <date>2023-06-20</date>
  </event>
</events>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<events>
  <event>
    <name>Conference</name>
    <date>2023-07-15</date>
  </event>
  <event>
    <name>Workshop</name>
    <date>2023-07-20</date>
  </event>
</events>`

	p := &XMLProcessor{}
	result, modCount, matchCount, err := p.ProcessContent(content, "//date", `
		local year, month, day = string.match(v.value, "(%d%d%d%d)-(%d%d)-(%d%d)")
		-- Postpone events by 1 month
		month = tonumber(month) + 1
		if month > 12 then
			month = 1
			year = tonumber(year) + 1
		end
		v.value = string.format("%04d-%02d-%s", tonumber(year), month, day)
	`)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_Error_InvalidXML(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<root>
  <unclosed>
</root>`

	p := &XMLProcessor{}
	_, _, _, err := p.ProcessContent(content, "//unclosed", "v1=v1")

	if err == nil {
		t.Errorf("Expected an error for invalid XML, but got none")
	}
}

func TestXMLProcessor_Process_Error_InvalidXPath(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<root>
  <element>value</element>
</root>`

	p := &XMLProcessor{}
	_, _, _, err := p.ProcessContent(content, "[invalid xpath]", "v1=v1")

	if err == nil {
		t.Errorf("Expected an error for invalid XPath, but got none")
	}
}

func TestXMLProcessor_Process_Error_InvalidLua(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<root>
  <element>123</element>
</root>`

	p := &XMLProcessor{}
	_, _, _, err := p.ProcessContent(content, "//element", "v1 = invalid_function()")

	if err == nil {
		t.Errorf("Expected an error for invalid Lua, but got none")
	}
}

func TestXMLProcessor_Process_ComplexXPathSelectors(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<library>
  <books>
    <book category="fiction" year="2020">
      <title>The Imaginary World</title>
      <author>Alice Johnson</author>
      <price>19.99</price>
    </book>
    <book category="non-fiction" year="2019">
      <title>History of Science</title>
      <author>Bob Smith</author>
      <price>29.99</price>
    </book>
    <book category="fiction" year="2021">
      <title>Future Tales</title>
      <author>Charlie Adams</author>
      <price>24.99</price>
    </book>
  </books>
</library>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<library>
  <books>
    <book category="fiction" year="2020">
      <title>The Imaginary World</title>
      <author>Alice Johnson</author>
      <price>15.99</price>
    </book>
    <book category="non-fiction" year="2019">
      <title>History of Science</title>
      <author>Bob Smith</author>
      <price>29.99</price>
    </book>
    <book category="fiction" year="2021">
      <title>Future Tales</title>
      <author>Charlie Adams</author>
      <price>19.99</price>
    </book>
  </books>
</library>`

	p := &XMLProcessor{}
	// Target only fiction books and apply 20% discount to price
	result, modCount, matchCount, err := p.ProcessContent(content, "//book[@category='fiction']/price", "v.value = round(v.value * 0.8, 2)")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_NestedStructureModification(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<game>
  <characters>
    <character id="hero">
      <stats>
        <strength>10</strength>
        <agility>15</agility>
        <intelligence>12</intelligence>
      </stats>
      <equipment>
        <weapon damage="5">Sword</weapon>
        <armor defense="3">Leather</armor>
      </equipment>
    </character>
    <character id="villain">
      <stats>
        <strength>14</strength>
        <agility>10</agility>
        <intelligence>16</intelligence>
      </stats>
      <equipment>
        <weapon damage="7">Axe</weapon>
        <armor defense="5">Chain Mail</armor>
      </equipment>
    </character>
  </characters>
</game>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<game>
  <characters>
    <character id="hero">
      <stats>
        <strength>12</strength>
        <agility>18</agility>
        <intelligence>14</intelligence>
      </stats>
      <equipment>
        <weapon damage="7">Sword</weapon>
        <armor defense="5">Leather</armor>
      </equipment>
    </character>
    <character id="villain">
      <stats>
        <strength>14</strength>
        <agility>10</agility>
        <intelligence>16</intelligence>
      </stats>
      <equipment>
        <weapon damage="7">Axe</weapon>
        <armor defense="5">Chain Mail</armor>
      </equipment>
    </character>
  </characters>
</game>`

	p := &XMLProcessor{}

	// Boost hero stats by 20%
	result, modCount, matchCount, err := p.ProcessContent(content, "//character[@id='hero']/stats/*", "v.value = round(v.value * 1.2)")
	if err != nil {
		t.Fatalf("Error processing stats content: %v", err)
	}

	// Also upgrade hero equipment
	result, modCount2, matchCount2, err := p.ProcessContent(result, "//character[@id='hero']/equipment/*/@damage|//character[@id='hero']/equipment/*/@defense", "v.value = v.value + 2")
	if err != nil {
		t.Fatalf("Error processing equipment content: %v", err)
	}

	totalMatches := matchCount + matchCount2
	totalMods := modCount + modCount2

	if totalMatches != 5 { // 3 stats + 2 equipment attributes
		t.Errorf("Expected 5 total matches, got %d", totalMatches)
	}

	if totalMods != 5 { // 3 stats + 2 equipment attributes
		t.Errorf("Expected 5 total modifications, got %d", totalMods)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ElementReplacement(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<items>
  <item type="fruit">
    <name>Apple</name>
    <price>1.99</price>
    <quantity>10</quantity>
  </item>
  <item type="vegetable">
    <name>Carrot</name>
    <price>0.99</price>
    <quantity>5</quantity>
  </item>
</items>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<items>
  <item type="fruit">
    <name>Apple</name>
    <price>1.99</price>
    <quantity>10</quantity>
    <total>19.90</total>
  </item>
  <item type="vegetable">
    <name>Carrot</name>
    <price>0.99</price>
    <quantity>5</quantity>
    <total>4.95</total>
  </item>
</items>`

	// This test demonstrates using variables from multiple elements to calculate a new value
	// With the table approach, we can directly access child elements
	p := &XMLProcessor{}

	luaExpr := `
	-- With a proper table approach, this becomes much simpler
	local price = tonumber(v.attr.price)
	local quantity = tonumber(v.attr.quantity)
	
	-- Add a new total element
	v.total = string.format("%.2f", price * quantity)
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "//item", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_AttributeAddition(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<products>
  <product id="p1">
    <name>Laptop</name>
    <price>999.99</price>
    <inStock>true</inStock>
  </product>
  <product id="p2">
    <name>Phone</name>
    <price>499.99</price>
    <inStock>false</inStock>
  </product>
</products>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<products>
  <product id="p1" status="available">
    <name>Laptop</name>
    <price>999.99</price>
    <inStock>true</inStock>
  </product>
  <product id="p2" status="out-of-stock">
    <name>Phone</name>
    <price>499.99</price>
    <inStock>false</inStock>
  </product>
</products>`

	// This test demonstrates adding a new attribute based on element content
	p := &XMLProcessor{}

	luaExpr := `
	-- With table approach, this becomes much cleaner
	-- We can access the "inStock" element directly
	if v.inStock == "true" then
		-- Add a new attribute directly
		v.attr = v.attr or {}
		v.attr.status = "available"
	else
		v.attr = v.attr or {}
		v.attr.status = "out-of-stock"
	end
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "//product", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ElementRemoval(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<users>
  <user>
    <name>John Smith</name>
    <email>john@example.com</email>
    <password>secret123</password>
    <role>admin</role>
  </user>
  <user>
    <name>Jane Doe</name>
    <email>jane@example.com</email>
    <password>pass456</password>
    <role>user</role>
  </user>
</users>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<users>
  <user>
    <name>John Smith</name>
    <email>john@example.com</email>
    <role>admin</role>
  </user>
  <user>
    <name>Jane Doe</name>
    <email>jane@example.com</email>
    <role>user</role>
  </user>
</users>`

	// This test demonstrates removing sensitive data elements
	p := &XMLProcessor{}

	luaExpr := `
	-- With table approach, element removal is trivial
	-- Just set the element to nil to remove it
	v.password = nil
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "//user", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ElementReordering(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<playlist>
  <song>
    <artist>Bob Dylan</artist>
    <title>Blowin' in the Wind</title>
    <year>1963</year>
  </song>
  <song>
    <artist>The Beatles</artist>
    <title>Hey Jude</title>
    <year>1968</year>
  </song>
</playlist>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<playlist>
  <song>
    <title>Blowin' in the Wind</title>
    <artist>Bob Dylan</artist>
    <year>1963</year>
  </song>
  <song>
    <title>Hey Jude</title>
    <artist>The Beatles</artist>
    <year>1968</year>
  </song>
</playlist>`

	// This test demonstrates reordering elements
	p := &XMLProcessor{}

	luaExpr := `
	-- With table approach, we can reorder elements by redefining the table
	-- Store the values
	local artist = v.attr.artist
	local title = v.attr.title 
	local year = v.attr.year
	
	-- Clear the table
	for k in pairs(v) do
		v[k] = nil
	end
	
	-- Add elements in the desired order
	v.attr.title = title
	v.attr.artist = artist
	v.attr.year = year
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "//song", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ComplexStructuralChange(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="fiction">
    <title>The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
    <year>1925</year>
    <price>10.99</price>
  </book>
  <book category="non-fiction">
    <title>A Brief History of Time</title>
    <author>Stephen Hawking</author>
    <year>1988</year>
    <price>15.99</price>
  </book>
</bookstore>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book>
    <details>
      <title>The Great Gatsby</title>
      <author>F. Scott Fitzgerald</author>
      <year>1925</year>
    </details>
    <pricing>
      <price currency="USD">10.99</price>
      <discount>0</discount>
    </pricing>
    <metadata>
      <category>fiction</category>
    </metadata>
  </book>
  <book>
    <details>
      <title>A Brief History of Time</title>
      <author>Stephen Hawking</author>
      <year>1988</year>
    </details>
    <pricing>
      <price currency="USD">15.99</price>
      <discount>0</discount>
    </pricing>
    <metadata>
      <category>non-fiction</category>
    </metadata>
  </book>
</bookstore>`

	// This test demonstrates a complete restructuring of the XML using table approach
	p := &XMLProcessor{}

	luaExpr := `
	-- Store the original values
	local category = v._attr and v._attr.category
	local title = v.title
	local author = v.author
	local year = v.year
	local price = v.price
	
	-- Clear the original structure
	for k in pairs(v) do
		v[k] = nil
	end
	
	-- Create a new nested structure
	v.details = {
		title = title,
		author = author,
		year = year
	}
	
	v.pricing = {
		price = {
			_attr = { currency = "USD" },
			_text = price
		},
		discount = "0"
	}
	
	v.metadata = {
		category = category
	}
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "//book", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_DynamicXPath(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <settings>
    <setting name="timeout" value="30" />
    <setting name="retries" value="3" />
    <setting name="backoff" value="exponential" />
  </settings>
  <advanced>
    <setting name="logging" value="debug" />
    <setting name="timeout" value="60" />
  </advanced>
</configuration>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <settings>
    <setting name="timeout" value="60"></setting>
    <setting name="retries" value="3"></setting>
    <setting name="backoff" value="exponential"></setting>
  </settings>
  <advanced>
    <setting name="logging" value="debug"></setting>
    <setting name="timeout" value="120"></setting>
  </advanced>
</configuration>`

	// This test demonstrates using specific XPath queries to select precise nodes
	p := &XMLProcessor{}

	// Double all timeout values in the configuration
	result, modCount, matchCount, err := p.ProcessContent(content, "//setting[@name='timeout']/@value", "v.value = v.value * 2")

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 2 {
		t.Errorf("Expected 2 matches, got %d", matchCount)
	}

	if modCount != 2 {
		t.Errorf("Expected 2 modifications, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_TableBasedStructureCreation(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<data>
  <settings>
    <option name="debug" value="false"/>
    <option name="log_level" value="info"/>
  </settings>
</data>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<data>
  <settings>
    <option name="debug" value="false"/>
    <option name="log_level" value="info"/>
  </settings>
  <calculated>
    <stats>
      <count>2</count>
      <summary>Debug: OFF, Logging: info</summary>
    </stats>
  </calculated>
</data>`

	// This test demonstrates adding a completely new section with nested structure
	p := &XMLProcessor{}

	luaExpr := `
	-- Count all options
	local count = 0
	local summary = ""
	
	-- Process each child option
	local settings = v.children[1]
	local options = settings.children
	-- if settings and options then
	-- 	if options.attr then
	-- 		options = {options}
	-- 	end
	-- 	
	-- 	for i, opt in ipairs(options) do
	-- 		count = count + 1
	-- 		if opt.attr.name == "debug" then
	-- 			summary = summary .. "Debug: " .. (opt.attr.value == "true" and "ON" or "OFF")
	-- 		elseif opt.attr.name == "log_level" then
	-- 			summary = summary .. "Logging: " .. opt.attr.value
	-- 		end
	-- 		
	-- 		if i < #options then
	-- 			summary = summary .. ", "
	-- 		end
	-- 	end
	-- end
	
	-- Create a new calculated section
	-- v.children[2] = {
	-- 	stats = {
	-- 		count = tostring(count),
	-- 		summary = summary
	-- 	}
	-- }
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "/data", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}

	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_ArrayManipulation(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<library>
  <books>
    <book>
      <title>Book 1</title>
      <pages>200</pages>
    </book>
    <book>
      <title>Book 2</title>
      <pages>150</pages>
    </book>
    <book>
      <title>Book 3</title>
      <pages>300</pages>
    </book>
  </books>
</library>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<library>
  <books>
    <book>
      <title>Book 3</title>
      <pages>300</pages>
    </book>
    <book>
      <title>Book 1</title>
      <pages>200</pages>
    </book>
  </books>
  <summary>
    <count>2</count>
    <total_pages>500</total_pages>
    <average_pages>250</average_pages>
  </summary>
</library>`

	// This test demonstrates advanced manipulation including:
	// 1. Sorting and filtering arrays of elements
	// 2. Calculating aggregates
	// 3. Generating summaries
	p := &XMLProcessor{}

	luaExpr := `
	-- Get the books array
	local books = v.books.book
	
	-- If only one book, wrap it in a table
	if books and not books[1] then
		books = {books}
	end
	
	-- Filter and sort books
	local filtered_books = {}
	local total_pages = 0
	
	for _, book in ipairs(books) do
		local pages = tonumber(book.pages) or 0
		
		-- Filter: only keep books with pages >= 200
		if pages >= 200 then
			total_pages = total_pages + pages
			table.insert(filtered_books, book)
		end
	end
	
	-- Sort books by number of pages (descending)
	table.sort(filtered_books, function(a, b)
		return tonumber(a.pages) > tonumber(b.pages)
	end)
	
	-- Replace the books array with our filtered and sorted one
	v.books.book = filtered_books
	
	-- Add summary information
	local count = #filtered_books
	local average_pages = count > 0 and math.floor(total_pages / count) or 0
	
	v.summary = {
		count = tostring(count),
		total_pages = tostring(total_pages),
		average_pages = tostring(average_pages)
	}
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "/library", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}

	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

func TestXMLProcessor_Process_DeepPathNavigation(t *testing.T) {
	content := `<?xml version="1.0" encoding="UTF-8"?>
<application>
  <config>
    <database>
      <connection>
        <host>localhost</host>
        <port>3306</port>
        <credentials>
          <username>admin</username>
          <password>secret</password>
        </credentials>
      </connection>
      <pool>
        <size>10</size>
        <timeout>30</timeout>
      </pool>
    </database>
    <logging>
      <level>info</level>
      <file>/var/log/app.log</file>
    </logging>
  </config>
</application>`

	expected := `<?xml version="1.0" encoding="UTF-8"?>
<application>
  <config>
    <database>
      <connection>
        <host>db.example.com</host>
        <port>5432</port>
        <credentials>
          <username>admin</username>
          <password>REDACTED</password>
        </credentials>
      </connection>
      <pool>
        <size>20</size>
        <timeout>60</timeout>
      </pool>
    </database>
    <logging>
      <level>debug</level>
      <file>/var/log/app.log</file>
    </logging>
  </config>
  <status>
    <environment>production</environment>
    <updated>true</updated>
    <secure>true</secure>
  </status>
</application>`

	// This test demonstrates navigating deeply nested elements in a complex XML structure
	p := &XMLProcessor{}

	luaExpr := `
	-- Update database connection settings
	v.config.database.connection.host = "db.example.com"
	v.config.database.connection.port = "5432"
	
	-- Redact sensitive information
	v.config.database.connection.credentials.password = "REDACTED"
	
	-- Double pool size and timeout
	v.config.database.pool.size = tostring(tonumber(v.config.database.pool.size) * 2)
	v.config.database.pool.timeout = tostring(tonumber(v.config.database.pool.timeout) * 2)
	
	-- Change logging level
	v.config.logging.level = "debug"
	
	-- Add a new status section
	v.status = {
		environment = "production",
		updated = "true",
		secure = tostring(v.config.database.connection.credentials.password == "REDACTED")
	}
	`

	result, modCount, matchCount, err := p.ProcessContent(content, "/application", luaExpr)

	if err != nil {
		t.Fatalf("Error processing content: %v", err)
	}

	if matchCount != 1 {
		t.Errorf("Expected 1 match, got %d", matchCount)
	}

	if modCount != 1 {
		t.Errorf("Expected 1 modification, got %d", modCount)
	}

	// Normalize whitespace for comparison
	normalizedResult := normalizeXMLWhitespace(result)
	normalizedExpected := normalizeXMLWhitespace(expected)

	if normalizedResult != normalizedExpected {
		t.Errorf("Expected content to be:\n%s\n\nGot:\n%s", expected, result)
	}
}

// Add more test cases for specific XML manipulation scenarios below
// These tests would cover additional functionality as the implementation progresses

func TestXMLToLua(t *testing.T) {
	// Sample XML to test with
	xmlStr := `
	<root id="1">
		<person name="John" age="30">
			<address type="home">
				<street>123 Main St</street>
				<city>Anytown</city>
				<zip>12345</zip>
			</address>
			<contact type="email">john@example.com</contact>
		</person>
		<person name="Jane" age="28">
			<address type="work">
				<street>456 Business Ave</street>
				<city>Worktown</city>
				<zip>54321</zip>
			</address>
			<contact type="phone">555-1234</contact>
		</person>
	</root>
	`

	// Parse the XML
	doc, err := xmlquery.Parse(strings.NewReader(xmlStr))
	if err != nil {
		t.Fatalf("Failed to parse XML: %v", err)
	}

	// Create a new Lua state
	L := lua.NewState()
	defer L.Close()

	// Create an XML processor
	processor := &XMLProcessor{}

	// Test converting the root element to Lua
	t.Run("RootElement", func(t *testing.T) {
		// Find the root element
		root := doc.SelectElement("root")
		if root == nil {
			t.Fatal("Failed to find root element")
		}

		// Convert to Lua
		table, err := processor.ToLua(L, root)
		if err != nil {
			t.Fatalf("Failed to convert to Lua: %v", err)
		}
		L.SetGlobal("v", table)

		// Verify the result
		luaTable := L.GetGlobal("v")
		if luaTable.Type() != lua.LTTable {
			t.Fatalf("Expected table, got %s", luaTable.Type().String())
		}

		// Check element type
		typeVal := L.GetField(luaTable, "type")
		if typeVal.String() != "element" {
			t.Errorf("Expected type 'element', got '%s'", typeVal.String())
		}

		// Check name
		nameVal := L.GetField(luaTable, "name")
		if nameVal.String() != "root" {
			t.Errorf("Expected name 'root', got '%s'", nameVal.String())
		}

		// Check attributes
		attrsTable := L.GetField(luaTable, "attributes")
		if attrsTable.Type() != lua.LTTable {
			t.Fatalf("Expected attributes table, got %s", attrsTable.Type().String())
		}

		idVal := L.GetField(attrsTable, "id")
		if idVal.String() != "1" {
			t.Errorf("Expected id '1', got '%s'", idVal.String())
		}

		// Check that we have children
		childrenTable := L.GetField(luaTable, "children")
		if childrenTable.Type() != lua.LTTable {
			t.Fatalf("Expected children table, got %s", childrenTable.Type().String())
		}
	})

	// Test converting a nested element to Lua
	t.Run("NestedElement", func(t *testing.T) {
		// Find a nested element
		street := doc.SelectElement("//street")
		if street == nil {
			t.Fatal("Failed to find street element")
		}

		// Convert to Lua
		table, err := processor.ToLua(L, street)
		if err != nil {
			t.Fatalf("Failed to convert to Lua: %v", err)
		}
		L.SetGlobal("v", table)

		// Verify the result
		luaTable := L.GetGlobal("v")
		if luaTable.Type() != lua.LTTable {
			t.Fatalf("Expected table, got %s", luaTable.Type().String())
		}

		// Check element type
		typeVal := L.GetField(luaTable, "type")
		if typeVal.String() != "element" {
			t.Errorf("Expected type 'element', got '%s'", typeVal.String())
		}

		// Check name
		nameVal := L.GetField(luaTable, "name")
		if nameVal.String() != "street" {
			t.Errorf("Expected name 'street', got '%s'", nameVal.String())
		}

		// Check value
		valueVal := L.GetField(luaTable, "value")
		if valueVal.String() != "123 Main St" {
			t.Errorf("Expected value '123 Main St', got '%s'", valueVal.String())
		}
	})

	// Test FromLua with a simple string update
	t.Run("FromLuaString", func(t *testing.T) {
		// Set up a Lua state with a string value
		L := lua.NewState()
		defer L.Close()
		L.SetGlobal("v", lua.LString("New Value"))

		// Convert from Lua
		result, err := processor.FromLua(L)
		if err != nil {
			t.Fatalf("Failed to convert from Lua: %v", err)
		}

		// Verify the result
		strResult, ok := result.(string)
		if !ok {
			t.Fatalf("Expected string result, got %T", result)
		}

		if strResult != "New Value" {
			t.Errorf("Expected 'New Value', got '%s'", strResult)
		}
	})

	// Test FromLua with a complex table update
	t.Run("FromLuaTable", func(t *testing.T) {
		// Set up a Lua state with a table value
		L := lua.NewState()
		defer L.Close()

		table := L.NewTable()
		L.SetField(table, "value", lua.LString("Updated Text"))

		attrTable := L.NewTable()
		L.SetField(attrTable, "id", lua.LString("new-id"))
		L.SetField(attrTable, "class", lua.LString("highlight"))

		L.SetField(table, "attributes", attrTable)
		L.SetGlobal("v", table)

		// Convert from Lua
		result, err := processor.FromLua(L)
		if err != nil {
			t.Fatalf("Failed to convert from Lua: %v", err)
		}

		// Verify the result
		mapResult, ok := result.(map[string]interface{})
		if !ok {
			t.Fatalf("Expected map result, got %T", result)
		}

		// Check value
		if value, ok := mapResult["value"]; !ok || value != "Updated Text" {
			t.Errorf("Expected value 'Updated Text', got '%v'", value)
		}

		// Check attributes
		attrs, ok := mapResult["attributes"].(map[string]interface{})
		if !ok {
			t.Fatalf("Expected attributes map, got %T", mapResult["attributes"])
		}

		if id, ok := attrs["id"]; !ok || id != "new-id" {
			t.Errorf("Expected id 'new-id', got '%v'", id)
		}

		if class, ok := attrs["class"]; !ok || class != "highlight" {
			t.Errorf("Expected class 'highlight', got '%v'", class)
		}
	})

	// Test updateNodeFromMap with a simple value update
	t.Run("UpdateNodeValue", func(t *testing.T) {
		// Create a simple element to update
		xmlStr := `<test>Original Text</test>`
		doc, _ := xmlquery.Parse(strings.NewReader(xmlStr))
		node := doc.SelectElement("test")

		// Create update data
		updateData := map[string]interface{}{
			"value": "Updated Text",
		}

		// Update the node
		updateNodeFromMap(node, updateData)

		// Verify the update
		if node.InnerText() != "Updated Text" {
			t.Errorf("Expected value 'Updated Text', got '%s'", node.InnerText())
		}
	})

	// Test updateNodeFromMap with attribute updates
	t.Run("UpdateNodeAttributes", func(t *testing.T) {
		// Create an element with attributes
		xmlStr := `<test id="old">Text</test>`
		doc, _ := xmlquery.Parse(strings.NewReader(xmlStr))
		node := doc.SelectElement("test")

		// Create update data
		updateData := map[string]interface{}{
			"attributes": map[string]interface{}{
				"id":    "new",
				"class": "added",
			},
		}

		// Update the node
		updateNodeFromMap(node, updateData)

		// Verify the id attribute was updated
		idFound := false
		classFound := false
		for _, attr := range node.Attr {
			if attr.Name.Local == "id" {
				idFound = true
				if attr.Value != "new" {
					t.Errorf("Expected id 'new', got '%s'", attr.Value)
				}
			}
			if attr.Name.Local == "class" {
				classFound = true
				if attr.Value != "added" {
					t.Errorf("Expected class 'added', got '%s'", attr.Value)
				}
			}
		}

		if !idFound {
			t.Error("Expected to find 'id' attribute but didn't")
		}

		if !classFound {
			t.Error("Expected to find 'class' attribute but didn't")
		}
	})
}