}

func TestProcInstEncoding(t *testing.T) {
	for _, test := range procInstTests {
		if got := procInst("version", test.input); got != test.expect[0] {
			t.Errorf("procInst(version, %q) = %q; want %q", test.input, got, test.expect[0])
		}
		if got := procInst("encoding", test.input); got != test.expect[1] {
			t.Errorf("procInst(encoding, %q) = %q; want %q", test.input, got, test.expect[1])
		}
	}
}

// Copy creates a new copy of Comment.
func (c Comment) Copy() Comment { return Comment(bytes.Clone(c)) }

// A ProcInst represents an XML processing instruction of the form <?target inst?>
type ProcInst struct {
	Target string
	Inst   []byte
}

// Copy creates a new copy of ProcInst.
func (p ProcInst) Copy() ProcInst {
	p.Inst = bytes.Clone(p.Inst)
	return p
}

	toks: []Token{
		ProcInst{"Target", []byte("Instruction")},
	},
	want: `<?Target Instruction?>`,
}, {
	desc: "proc instruction with empty target",
	toks: []Token{
		ProcInst{"", []byte("Instruction")},
	},
	err: "xml: EncodeToken of ProcInst with invalid Target",
}, {
	desc: "proc instruction with bad content",
	toks: []Token{
		ProcInst{"", []byte("Instruction?>")},
	},

		p.Write(t)
		p.WriteString("-->")
		return p.cachedWriteError()
	case ProcInst:
		// First token to be encoded which is also a ProcInst with target of xml
		// is the xml declaration. The only ProcInst where target of xml is allowed.
		if t.Target == "xml" && p.w.Buffered() != 0 {
			return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
		}

					httpMetricVal, err = util.QueryPrometheus(t, cluster, httpDestinationQuery, promInst)
					if err != nil {
						util.PromDiff(t, promInst, cluster, httpDestinationQuery)
						return err
					}
					httpChecked = true
				}
				_, err = util.QueryPrometheus(t, cluster, grpcDestinationQuery, promInst)
				if err != nil {
					util.PromDiff(t, promInst, cluster, grpcDestinationQuery)
					return err
				}
				return nil

		{"Name", Type, 0},
		{"Name.Local", Field, 0},
		{"Name.Space", Field, 0},
		{"NewDecoder", Func, 0},
		{"NewEncoder", Func, 0},
		{"NewTokenDecoder", Func, 10},
		{"ProcInst", Type, 0},
		{"ProcInst.Inst", Field, 0},
		{"ProcInst.Target", Field, 0},
		{"StartElement", Type, 0},
		{"StartElement.Attr", Field, 0},
		{"StartElement.Name", Field, 0},
		{"SyntaxError", Type, 0},
		{"SyntaxError.Line", Field, 0},

								return err
							}
							if _, err := util.QueryPrometheus(t, cluster, grpcSourceQuery, promInst); err != nil {
								util.PromDiff(t, promInst, cluster, grpcSourceQuery)
								return err
							}
							return nil
						}, retry.Delay(1*time.Second), retry.Timeout(300*time.Second))
						util.ValidateMetric(t, cluster, promInst, grpcSourceQuery, 1)
					})
				})
			}
		})
}

	"istio.io/istio/pkg/test/framework/resource/config/apply"
)

const (
	DefaultBucketCount = 20
)

var (
	apps cdeployment.SingleNamespaceView

	mockProm echo.Instances
	ist      istio.Instance
	promInst prometheus.Instance
	ingr     []ingress.Instance
)

func TestMain(m *testing.M) {
	framework.NewSuite(m).
		Label(label.CustomSetup).

func QueryPrometheus(t framework.TestContext, cluster cluster.Cluster, query prometheus.Query, promInst prometheus.Instance) (string, error) {
	t.Helper()
	t.Logf("query prometheus with: %v", query)

	val, err := promInst.Query(cluster, query)
	if err != nil {
		return "", err
	}
	got, err := prometheus.Sum(val)
	if err != nil {
		t.Logf("value: %s", val.String())

		q := prometheus.Query{Metric: "istio_agent_wasm_remote_fetch_count", Labels: map[string]string{"result": "download_failure"}}
		c := to.Config().Cluster
		if _, err := util.QueryPrometheus(t, c, q, promInst); err != nil {
			util.PromDiff(t, promInst, c, q)
			return err
		}
		return nil
	}, retry.Delay(1*time.Second), retry.Timeout(80*time.Second))