"port": "portValue",
                "host": "hostValue",
                "scheme": "schemeValue",
                "httpHeaders": [
                  {
                    "name": "nameValue",
                    "value": "valueValue"
                  }
                ]
              },
              "tcpSocket": {
                "port": "portValue",

					cases := []struct {
						ports []echo.Port
						path  string
						allow allowValue
					}{
						{
							ports: []echo.Port{ports.GRPC, ports.TCP},
							allow: allow,
						},
						{
							ports: []echo.Port{ports.HTTP, ports.HTTP2},
							path:  "/allow",
							allow: allow,
						},
						{
							ports: []echo.Port{ports.HTTP, ports.HTTP2},
							path:  "/allow?param=value",

		"http": 80,
	}

	for _, port := range ingress.service.Spec.Ports {
		if port.Protocol != "TCP" || !portsToShow[port.Name] {
			continue
		}

		// Get port number
		_, err := pilotcontroller.FindPort(ingress.pods[0], &port)
		if err == nil {
			nport := int(port.Port)
			protocol := string(configKube.ConvertProtocol(port.Port, port.Name, port.Protocol, port.AppProtocol))

            "path": "pathValue",
            "port": "portValue",
            "host": "hostValue",
            "scheme": "schemeValue",
            "httpHeaders": [
              {
                "name": "nameValue",
                "value": "valueValue"
              }
            ]
          },
          "tcpSocket": {
            "port": "portValue",
            "host": "hostValue"
          },

                      }
                    ]
                  },
                  "tcpSocket": {
                    "port": "portValue",
                    "host": "hostValue"
                  },
                  "grpc": {
                    "port": 1,
                    "service": "serviceValue"
                  },
                  "initialDelaySeconds": 2,

                "port": "portValue",
                "host": "hostValue",
                "scheme": "schemeValue",
                "httpHeaders": [
                  {
                    "name": "nameValue",
                    "value": "valueValue"
                  }
                ]
              },
              "tcpSocket": {
                "port": "portValue",

		assert.Equal(t, out, want)
	}

	for _, c := range cases {
		c := c
		t.Run(c.name, func(t *testing.T) {
			test.SetForTest[bool](t, &features.EnableDualStack, c.enableDualStack)
			testFn(t, c.service, c.port, c.node, c.want)
		})
	}
}

func TestSidecarOutboundHTTPRouteConfigWithDuplicateHosts(t *testing.T) {
	virtualServiceSpec := &networking.VirtualService{

				t.Fatalf("expected %d listeners, found %d", len(tc.expectedListener), len(listeners))
			}
			for _, port := range tc.expectedListener {
				l := findListenerByPort(listeners, uint32(port))
				if l == nil {
					t.Fatalf("found no listener with port %d", port)
				}
			}
		})
	}
}

func TestOutboundListenerDualStackWildcard(t *testing.T) {

		}
	}

	// Now group these Services by port so that we can infer the destination.port if the user
	// doesn't specify any port for a multiport service. We need to know the destination port in
	// order to build the cluster name (outbound|<port>|<subset>|<serviceFQDN>)
	// If the destination service is being accessed on port X, we set that as the default
	// destination port
	serviceByPort := make(map[int][]*model.Service)

			expected: true,
		},
		{
			name: "port",
			root: &networking.HTTPMatchRequest{
				Port: 0,
			},
			leaf: &networking.HTTPMatchRequest{
				Port: 8080,
			},
			expected: false,
		},
		{
			name: "port",
			root: &networking.HTTPMatchRequest{
				Port: 8080,
			},
			leaf: &networking.HTTPMatchRequest{
				Port: 0,
			},
			expected: false,
		},
		{