if err != nil {
				rpt.SetStatus(bucket, fileName, fmt.Errorf("%s (%s)", errorCodes[ErrMalformedXML].Description, err))
				continue
			}

			configData, err := xml.Marshal(config)
			if err != nil {
				rpt.SetStatus(bucket, fileName, err)
				continue
			}

			bucketMap[bucket].NotificationConfigXML = configData
			rpt.SetStatus(bucket, fileName, nil)
		case bucketPolicyConfig:

			}
			// If PreFilter fails, then Filter will not run.
			if test.preFilterWantStatus.IsSuccess() {
				gotStatus := p.(framework.FilterPlugin).Filter(ctx, cycleState, test.pod, test.nodeInfo)
				if diff := cmp.Diff(test.wantStatus, gotStatus); diff != "" {
					t.Errorf("Unexpected Filter status (-want, +got): %s", diff)
				}
			}
		})
	}
}

	}
	cycleState := framework.NewCycleState()
	gotStatus := p.(framework.FilterPlugin).Filter(ctx, cycleState, pod, nodeInfo)
	wantStatus := framework.AsStatus(fmt.Errorf(`reading "PreFilterNodePorts" from cycleState: %w`, framework.ErrNotFound))
	if !reflect.DeepEqual(gotStatus, wantStatus) {
		t.Errorf("status does not match: %v, want: %v", gotStatus, wantStatus)
	}
}

func TestGetContainerPorts(t *testing.T) {

				t.Errorf("PreFilter status does not match (-want, +got): %s", diff)
			}

			if gotPreFilterStatus.Code() != framework.Skip {
				gotStatus := p.Filter(ctx, nil, test.newPod, node)
				if !reflect.DeepEqual(gotStatus, test.wantStatus) {
					t.Errorf("Filter status does not match: %v, want: %v", gotStatus, test.wantStatus)
				}
			}
		})
	}
}

func TestAzureDiskLimits(t *testing.T) {

            if (req.method == "PUT") {
                res.setHeader("location", "/ok")
                res.setStatus(301)
                res.writer.close()
                false
            } else if (req.requestURI == "/ok") {
                res.setStatus(200)
                res.writer.close()
                false
            } else {
                true
            }
        }

                public void setResult(@Nullable Object result) {
                    context.setResult(result);
                }

                @Override
                public void setStatus(String status) {
                    context.setStatus(status);
                }

                @Override
                public void progress(String status) {
                    context.progress(status);
                }

                assert accept.length == 2
                assert accept[0] == HttpBuildCacheService.BUILD_CACHE_CONTENT_TYPE
                assert accept[1] == "*/*"

                response.setStatus(200)
            }
        })

        expect:
        cache.load(key) { input -> }
    }

    def "sends X-Gradle-Version and Content-Type headers on PUT"() {

                }
            }
        }).execute()) {

            try (ServletOutputStream out = response.getOutputStream(); InputStream in = curlResponse.getContentAsStream()) {
                response.setStatus(curlResponse.getHttpStatusCode());
                writeHeaders(response);
                final String responseContentType = curlResponse.getHeaderValue("Content-Type");

				t.Fatalf("Creating plugin: %v", err)
			}

			state := framework.NewCycleState()
			var gotStatus *framework.Status
			if test.runPreFilter {
				gotPreFilterResult, gotStatus := p.(framework.PreFilterPlugin).PreFilter(context.Background(), state, test.pod)
				if diff := cmp.Diff(test.wantPreFilterStatus, gotStatus); diff != "" {
					t.Errorf("unexpected PreFilter Status (-want,+got):\n%s", diff)
				}

			p, err := New(ctx, nil, nil, feature.Features{})
			if err != nil {
				t.Fatalf("creating plugin: %v", err)
			}
			gotStatus := p.(framework.FilterPlugin).Filter(ctx, nil, test.pod, nodeInfo)
			if !reflect.DeepEqual(gotStatus, test.wantStatus) {
				t.Errorf("status does not match: %v, want: %v", gotStatus, test.wantStatus)
			}
		})
	}
}

func TestIsSchedulableAfterNodeChange(t *testing.T) {
	tests := []struct {