t.Errorf("unexpected commands: %v", fakeCommandRunner)
	}
}

type fakeHTTP struct {
	url     string
	headers http.Header
	err     error
	resp    *http.Response
}

func (f *fakeHTTP) Do(req *http.Request) (*http.Response, error) {
	f.url = req.URL.String()
	f.headers = req.Header.Clone()
	return f.resp, f.err
}

func TestRunHandlerHttp(t *testing.T) {
	ctx := context.Background()

                        },
                        "configuration": {
                            "@type": "type.googleapis.com/google.protobuf.StringValue",
                            "value": "{\"header_1\":\"some_value_1\",\"header_2\":\"another_value\"}"
                        }
                    }
                }
            },
            "lastUpdated": "2022-12-08T11:03:53.225Z"
        },
        {

								Host:    "localhost",
								Path:    "/check",
								Headers: map[string]string{checkHeader: tc.header},
							},
						},
					},
				})
				if err != nil {
					t.Errorf(err.Error())
				} else {
					got = int(resp.Status.Code)
				}
			} else {
				httpReq.Header.Set(checkHeader, tc.header)
				resp, err := httpClient.Do(httpReq)
				if err != nil {

	return rt.RoundTripper
}

// removeCORSHeaders strip CORS headers sent from the backend
// This should be called on all responses before returning
func removeCORSHeaders(resp *http.Response) {
	resp.Header.Del("Access-Control-Allow-Credentials")
	resp.Header.Del("Access-Control-Allow-Headers")
	resp.Header.Del("Access-Control-Allow-Methods")
	resp.Header.Del("Access-Control-Allow-Origin")

                    detail="Not authenticated",
                    headers=unauthorized_headers,
                )
            else:
                return None
        invalid_user_credentials_exc = HTTPException(
            status_code=HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers=unauthorized_headers,
        )
        try:

    }
  }
  return null
}

internal fun Headers.Builder.commonAdd(
  name: String,
  value: String,
) = apply {
  headersCheckName(name)
  headersCheckValue(value, name)
  commonAddLenient(name, value)
}

internal fun Headers.Builder.commonAddAll(headers: Headers) =
  apply {
    for (i in 0 until headers.size) {
      commonAddLenient(headers.name(i), headers.value(i))
    }
  }

            void cOut() {
                printf(OUTPUT);
            }
"""

        and: "Library header files define different OUTPUT values"

        file("src/libCpp/headers/output.h") << """
            #define OUTPUT "CPP"
"""

        file("src/libC/headers/output.h") << """
            #define OUTPUT "C"
"""

        when:
        succeeds "installMainExecutable"

                                "configuration": {
                                    "@type": "type.googleapis.com/google.protobuf.StringValue",
                                    "value": "{\"header_1\":\"some_value_1\",\"header_2\":\"another_value\"}"
                                }
                            }
                        }
                    },
                    "last_updated": "2022-12-08T11:03:53.225Z"

	// Headers, leaving it uninitialized. We guarantee to the
	// Transport that this has been initialized, though.
	if req.Header == nil {
		forkReq()
		req.Header = make(Header)
	}

	if u := req.URL.User; u != nil && req.Header.Get("Authorization") == "" {
		username := u.Username()
		password, _ := u.Password()
		forkReq()
		req.Header = cloneOrMakeHeader(ireq.Header)

        assert source.Filter[0].text() == 'Source Files'
        return source.'@Include'
    }

    private String headerFile(int index) {
        def header = itemGroup('Headers').ClInclude[index]
        assert header.Filter[0].text() == 'Header Files'
        return header.'@Include'
    }

    private Node itemGroup(String label) {
        return filtersXml.ItemGroup.find({it.'@Label' == label}) as Node
    }