builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "foo", "-b", "bar")
				builder.InsertRuleV6(iptableslog.UndefinedCommand, "chain", "table", 2, "-f", "foo", "-b", "bar")
				builder.InsertRuleV6(iptableslog.UndefinedCommand, "chain", "table", 1, "-f", "foo", "-b", "bar")
				builder.AppendRuleV4(iptableslog.UndefinedCommand, constants.PREROUTING, constants.NAT, "-f", "foo", "-b", "bar")
			},

				},
			},
			port:      servicePort[0],
			proxyView: model.ProxyViewAll,
			destRule: &networking.DestinationRule{
				Host: "foo.example.com",
				Subsets: []*networking.Subset{{
					Name:   "v1",
					Labels: map[string]string{"foo": "bar"},
				}},
			},
			expectedSubsetClusters: []*cluster.Cluster{{
				Name:                 "outbound|8080|v1|foo.example.com",

                    println('circular in indirect => ' + (circular in indirect))
                    println('Circular(foo, bar) in direct => ' + (new Circular('foo', 'bar') in direct))
                    println('Circular(foo, bar) in indirect => ' + (new Circular('foo', 'bar') in indirect))
                    println('circular === direct.first() => ' + (circular === direct.first()))

			oldObj:       st.MakePod().Name("p1").SchedulingGates([]string{"foo", "bar"}).UID("uid1").Obj(),
			newObj:       st.MakePod().Name("p1").SchedulingGates([]string{"foo"}).UID("uid1").Obj(),
			expectedHint: framework.QueueSkip,
		},
		"skip-queue-on-gates-not-empty": {
			pod:          st.MakePod().Name("p").SchedulingGates([]string{"foo", "bar"}).Obj(),

* nat
-A PREROUTING -f foo -b bar
COMMIT
* table
-N chain
-A chain -f foo -b bar
-I chain 2 -f foo -b bar
-A chain -f foo -b baz

-t table -N chain
-t table -A chain -f foo -b bar
-t table -I chain 2 -f foo -b bar
-t table -A chain -f foo -b baz

                public Foo getFoo() {
                    return foo;
                }

                @Configuring
                public void foo(Action<? super Foo> action) {
                    action.execute(foo);
                }

                public abstract static class Foo {
                    public Foo() {
                        this.getBar().convention("nothing");

							TargetPort:  8080,
						}},
					},
					LabelSelector: model.NewSelector(map[string]string{"app": "foo"}),
				},
			},
			pod: &v1.Pod{
				TypeMeta: metav1.TypeMeta{},
				ObjectMeta: metav1.ObjectMeta{
					Name:      "name",
					Namespace: "ns",
					Labels: map[string]string{
						"app": "foo",
					},
				},
				Spec: v1.PodSpec{},
				Status: v1.PodStatus{
					Phase:      v1.PodRunning,

        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOps = buildOperations.all(RealizeTaskBuildOperationType)
        realizeOps.size() == 2
        realizeOps*.details.each {
            assert it.taskPath == ":foo"
        }
        realizeOps.first().details.eager == false

* table
-N chain
-A chain -f foo -b bar
-I chain 2 -f foo -b bar
-I chain 1 -f foo -b bar