Creates the missing column check
@param expectedHeader The expected header
@param caseSensitive Is the header case sensitive
@param severity The severity if the check fails
544153
function getMissingColumnCheck(expectedHeader, caseSensitive, severity) {

	return function (content) {
		let actualHeader;
		if (caseSensitive) {
			actualHeader = content;
		} else {
			actualHeader = arrayToUpperCase(content);
			expectedHeader = arrayToUpperCase(expectedHeader);
		}

		// the header must have all the expected columns but may have more
		let err = _missingColumns(expectedHeader, actualHeader);
		if (err) {
			return {
				errorCode: 'CHECK_HEADER_MISSING_COLUMNS',
				severity: severity,
				message: 'The following columns are missing in the header: [' + err.join() + ']'
			};
		}
	};
}
393122
@Override
    public boolean containsHeader(String name) {
        return (headers != null && headers.get(name) != null && !headers.get(name).isEmpty());
    }
982624
public HttpClientVerifyBuilder withHeader(String header, Matcher<String> matcher) {
        ruleBuilder.addCondition(new HeaderCondition(header, matcher));
        return this;
    }
1061133
public void addColumn(Column<T, ?> column, Header<?> header,
                          boolean sortable) {
        addColumn(column, header);
        column.setSortable(sortable);
        if (sortable) {
            defaultSortOrderMap.put(column, true);
        }
    }
928400
public void setCaseSensitiveMatch(final Boolean caseInsensitive) {
		FilterableBeanBoundDataModel model = getFilterableTableModel();
		if (model != null) {
			model.setCaseSensitiveMatch(caseInsensitive);
		}
	}
1324556
public void changeColumnsHeaders(LinkedHashMap<String, String> newColumnValues) throws Exception {
		for (String oldColumn : newColumnValues.keySet()) {
			String newColumn = newColumnValues.get(oldColumn);
			changeColumnHeader(oldColumn, newColumn);
		}

	}
117412
private void ensureColumn(FieldDescriptorDef fieldDef, String checkLevel)
    {
        if (!fieldDef.hasProperty(PropertyHelper.OJB_PROPERTY_COLUMN))
        {
            String javaname = fieldDef.getName();

            if (fieldDef.isNested())
            {    
                int pos = javaname.indexOf("::");

                // we convert nested names ('_' for '::')
                if (pos > 0)
                {
                    StringBuffer newJavaname = new StringBuffer(javaname.substring(0, pos));
                    int          lastPos     = pos + 2;

                    do
                    {
                        pos = javaname.indexOf("::", lastPos);
                        newJavaname.append("_");
                        if (pos > 0)
                        {    
                            newJavaname.append(javaname.substring(lastPos, pos));
                            lastPos = pos + 2;
                        }
                        else
                        {
                            newJavaname.append(javaname.substring(lastPos));
                        }
                    }
                    while (pos > 0);
                    javaname = newJavaname.toString();
                }
            }
            fieldDef.setProperty(PropertyHelper.OJB_PROPERTY_COLUMN, javaname);
        }
    }
1146150
public HttpClientMockBuilder withHeader(String header, String value) {
        return withHeader(header, equalTo(value));
    }
671104
public static Condition withHeader(final String key, final String... expectedHeaders) {
        return new Condition(input -> {
            for (Map.Entry<String, List<String>> e : input.getHeaders().entrySet()) {
                if (e.getKey().equalsIgnoreCase(key)) {
                    return (expectedHeaders == null && e.getValue() == null)
                            || match(e.getValue(), asList(expectedHeaders));
                }
            }
            return false;
        });
    }
559519
def assert_headers(context):
    
    expected_headers = [(k, v) for k, v in row_table(context).items()]
    request = httpretty.last_request()
    actual_headers = request.headers.items()

    for expected_header in expected_headers:
        assert_in(expected_header, actual_headers)
171760
public function assertHasHeader(string $expected)
    {
        $actual = $this->getHeaderText();
        if ($expected === $actual) {
            return;
        }

        throw new ExpectationException(
            sprintf(
                '[W402] Expected screen header "%1$s", found "%2$s".',
                $expected,
                $actual
            ),
            $this->getDriver()
        );
    }
424319
public CSVParserBuilder<T, K> usingExplicitHeader(String... header) {
        Objects.requireNonNull(subsetView);
        this.subsetView = FieldSubsetView.forExplicitHeader(subsetView.getFieldSubset(), header);
        return this;
    }
1154940
def _in_header(self, col):
        """"""
        # pylint: disable=R1704
        if not self._has_header:
            # Conditionally register exceptions so that they do not appear
            # in situations where has_header is always True. In this way
            # they are not auto-documented by default
            icol_ex = pexdoc.exh.addex(RuntimeError, "Invalid column specification")
        hnf_ex = pexdoc.exh.addex(ValueError, "Column *[column_identifier]* not found")
        col_list = [col] if isinstance(col, (str, int)) else col
        for col in col_list:
            edata = {"field": "column_identifier", "value": col}
            if not self._has_header:
                # Condition not subsumed in raise_exception_if
                # so that calls that always have has_header=True
                # do not pick up this exception
                icol_ex(not isinstance(col, int))
                hnf_ex((col < 0) or (col > len(self._header) - 1), edata)
            else:
                hnf_ex(
                    (isinstance(col, int) and ((col < 0) or (col > self._data_cols)))
                    or (
                        isinstance(col, str) and (col.upper() not in self._header_upper)
                    ),
                    edata,
                )
        return col_list
775733
public String getHeader(@NotNull final String name, String defaultValue) {
        if (headers().contains(name)) {
            return getHeader(name);
        } else {
            return defaultValue;
        }
    }
298303
def assertHeader(self, name, value=None, *args, **kwargs):
        
        return name in self.raw_headers and (
            True if value is None else self.raw_headers[name] == value)
796413
public static void addDefaultHeader(String key, String value) {
		if (isNotBlank(key) && isNotBlank(value)) {
			if (defaultHeader == null) {
				defaultHeader = new HashMap<String, String>();
			}
			defaultHeader.put(key, value);
		}
	}
381267
public void addIntHeader (@Nonnull @Nonempty final String sName, final int nValue)
  {
    _addHeader (sName, Integer.toString (nValue));
  }