return b.tcpFilters
}

func (b *Builder) BuildHTTP(class networking.ListenerClass) []*hcm.HttpFilter {
	if b == nil || b.builder == nil {
		return nil
	}
	if class == networking.ListenerClassSidecarOutbound {
		// Only applies to inbound and gateways
		return nil
	}
	if b.httpBuilt {
		return b.httpFilters
	}
	b.httpBuilt = true
	b.httpFilters = b.builder.BuildHTTP()

	return b.httpFilters

		option := fuzz.Struct[Option](fg)
		b := New(bundle, push, policies, option)
		if b == nil {
			fg.T().Skip()
			return // To help linter
		}
		b.BuildHTTP()
	})
}

func FuzzBuildTCP(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		bundle := fuzz.Struct[trustdomain.Bundle](fg)
		push := fuzz.Struct[*model.PushContext](fg, validatePush)

		allowPolicies:     policies.Allow,
		auditPolicies:     policies.Audit,
		trustDomainBundle: trustDomainBundle,
		option:            option,
	}
}

// BuildHTTP returns the HTTP filters built from the authorization policy.
func (b Builder) BuildHTTP() []*hcm.HttpFilter {
	b.logger = &AuthzLogger{}
	defer b.logger.Report()
	if b.option.IsCustomBuilder {

    // In other tests, explicit assertions may be helpful.
    policies := push.AuthzPolicies.ListAuthorizationPolicies(selectionOpts)
    New(bundle, push, policies, option).BuildHTTP()
  })
}
```

## Running tests

Fuzz tests can be run using standard Go tooling:

```shell
go test ./path/to/pkg -v -run=^$ -fuzz=Fuzz
```

## CI testing

		resp = append(resp, b.applier.InboundMTLSSettings(port, b.proxy, b.trustDomains, authn.NoOverride))
	}
	return resp
}

func (b *Builder) BuildHTTP(class networking.ListenerClass) []*hcm.HttpFilter {
	if b == nil {
		return nil
	}
	if class == networking.ListenerClassSidecarOutbound {
		// Only applies to inbound and gateways
		return nil
	}

		filters = append(filters, lb.authzCustomBuilder.BuildHTTP(httpOpts.class)...)
		filters = extension.PopAppendHTTP(filters, wasm, extensions.PluginPhase_AUTHN)
		filters = append(filters, lb.authnBuilder.BuildHTTP(httpOpts.class)...)
		filters = extension.PopAppendHTTP(filters, wasm, extensions.PluginPhase_AUTHZ)
		filters = append(filters, lb.authzBuilder.BuildHTTP(httpOpts.class)...)

	pre = append(pre, authzCustomBuilder.BuildHTTP(cls)...)
	pre = extension.PopAppendHTTP(pre, wasm, extensions.PluginPhase_AUTHN)
	pre = append(pre, authnBuilder.BuildHTTP(cls)...)
	pre = extension.PopAppendHTTP(pre, wasm, extensions.PluginPhase_AUTHZ)
	pre = append(pre, authzBuilder.BuildHTTP(cls)...)

				policies := push.AuthzPolicies.ListAuthorizationPolicies(selectionOpts)
				g := New(tc.tdBundle, push, policies, option)
				if g == nil {
					t.Fatalf("failed to create generator")
				}
				got := g.BuildHTTP()
				wants := tc.want
				if extended {
					for i := range wants {
						wants[i] = "extended-" + wants[i]
					}
				}
				verify(t, convertHTTP(got), baseDir, tc.want, false /* forTCP */)
			})