text:
namespace iControl {
	using System.Xml.Serialization;
	using System.Web.Services;
	using System.ComponentModel;
	using System.Web.Services.Protocols;
	using System;
	using System.Diagnostics;

	/// <remarks/>
	[System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "2.0.50727.3038")]
	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.ComponentModel.DesignerCategoryAttribute("code")]
	[System.Web.Services.WebServiceBindingAttribute(Name="ASM.LoggingProfileBinding", Namespace="urn:iControl")]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(CommonIPPortDefinition))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(ASMLoggingProfileDefinition))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(ASMLoggingRemoteStorageBase))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(ASMLoggingRequestSearch))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(ASMLoggingStorageFormat))]
	public partial class ASMLoggingProfile : iControlInterface {
		public ASMLoggingProfile() {
			this.Url = "https://url_to_service";
		}

	//=======================================================================
	// Operations
	//=======================================================================
	//-----------------------------------------------------------------------
	// add_remote_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void add_remote_server(
		string [] logprof_names,
		CommonIPPortDefinition [] [] ip_ports
	) {
		this.Invoke("add_remote_server", new object [] {
				logprof_names,
				ip_ports});

	}
	public System.IAsyncResult Beginadd_remote_server(string [] logprof_names,CommonIPPortDefinition [] [] ip_ports, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("add_remote_server", new object[] {
			logprof_names,
			ip_ports}, callback, asyncState);
	}
	public void Endadd_remote_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// apply_logprof
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void apply_logprof(
		string [] logprof_names
	) {
		this.Invoke("apply_logprof", new object [] {
				logprof_names});

	}
	public System.IAsyncResult Beginapply_logprof(string [] logprof_names, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("apply_logprof", new object[] {
			logprof_names}, callback, asyncState);
	}
	public void Endapply_logprof(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// create
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void create(
		string [] logprof_names
	) {
		this.Invoke("create", new object [] {
				logprof_names});

	}
	public System.IAsyncResult Begincreate(string [] logprof_names, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("create", new object[] {
			logprof_names}, callback, asyncState);
	}
	public void Endcreate(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// delete_logprof
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void delete_logprof(
		string [] logprof_names
	) {
		this.Invoke("delete_logprof", new object [] {
				logprof_names});

	}
	public System.IAsyncResult Begindelete_logprof(string [] logprof_names, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("delete_logprof", new object[] {
			logprof_names}, callback, asyncState);
	}
	public void Enddelete_logprof(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// get_list
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string [] get_list(

	) {
		object [] results = this.Invoke("get_list", new object [0]);
		return ((string [])(results[0]));
	}
	public System.IAsyncResult Beginget_list(System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_list", new object[0], callback, asyncState);
	}
	public string [] Endget_list(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_logprof
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public ASMLoggingProfileDefinition [] get_logprof(
		string [] logprof_names
	) {
		object [] results = this.Invoke("get_logprof", new object [] {
				logprof_names});
		return ((ASMLoggingProfileDefinition [])(results[0]));
	}
	public System.IAsyncResult Beginget_logprof(string [] logprof_names, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_logprof", new object[] {
			logprof_names}, callback, asyncState);
	}
	public ASMLoggingProfileDefinition [] Endget_logprof(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((ASMLoggingProfileDefinition [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_version
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string get_version(

	) {
		object [] results = this.Invoke("get_version", new object [] {
});
		return ((string)(results[0]));
	}
	public System.IAsyncResult Beginget_version(System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_version", new object[] {
}, callback, asyncState);
	}
	public string Endget_version(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string)(results[0]));
	}

	//-----------------------------------------------------------------------
	// remove_remote_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void remove_remote_server(
		string [] logprof_names,
		CommonIPPortDefinition [] [] ip_ports
	) {
		this.Invoke("remove_remote_server", new object [] {
				logprof_names,
				ip_ports});

	}
	public System.IAsyncResult Beginremove_remote_server(string [] logprof_names,CommonIPPortDefinition [] [] ip_ports, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("remove_remote_server", new object[] {
			logprof_names,
			ip_ports}, callback, asyncState);
	}
	public void Endremove_remote_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// rename
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void rename(
		string [] logprof_names,
		string [] new_logprof_names
	) {
		this.Invoke("rename", new object [] {
				logprof_names,
				new_logprof_names});

	}
	public System.IAsyncResult Beginrename(string [] logprof_names,string [] new_logprof_names, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("rename", new object[] {
			logprof_names,
			new_logprof_names}, callback, asyncState);
	}
	public void Endrename(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// replace_http_method
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void replace_http_method(
		string [] logprof_names,
		string [] [] http_methods
	) {
		this.Invoke("replace_http_method", new object [] {
				logprof_names,
				http_methods});

	}
	public System.IAsyncResult Beginreplace_http_method(string [] logprof_names,string [] [] http_methods, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("replace_http_method", new object[] {
			logprof_names,
			http_methods}, callback, asyncState);
	}
	public void Endreplace_http_method(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// replace_response_code
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void replace_response_code(
		string [] logprof_names,
		long [] [] response_codes
	) {
		this.Invoke("replace_response_code", new object [] {
				logprof_names,
				response_codes});

	}
	public System.IAsyncResult Beginreplace_response_code(string [] logprof_names,long [] [] response_codes, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("replace_response_code", new object[] {
			logprof_names,
			response_codes}, callback, asyncState);
	}
	public void Endreplace_response_code(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_description
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_description(
		string [] logprof_names,
		string [] descriptions
	) {
		this.Invoke("set_description", new object [] {
				logprof_names,
				descriptions});

	}
	public System.IAsyncResult Beginset_description(string [] logprof_names,string [] descriptions, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_description", new object[] {
			logprof_names,
			descriptions}, callback, asyncState);
	}
	public void Endset_description(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_filter_protocol
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_filter_protocol(
		string [] logprof_names,
		ASMProtocolType [] filter_protocols
	) {
		this.Invoke("set_filter_protocol", new object [] {
				logprof_names,
				filter_protocols});

	}
	public System.IAsyncResult Beginset_filter_protocol(string [] logprof_names,ASMProtocolType [] filter_protocols, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_filter_protocol", new object[] {
			logprof_names,
			filter_protocols}, callback, asyncState);
	}
	public void Endset_filter_protocol(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_guarantee_logging_flag
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_guarantee_logging_flag(
		string [] logprof_names,
		bool [] guarantee_logging_flags
	) {
		this.Invoke("set_guarantee_logging_flag", new object [] {
				logprof_names,
				guarantee_logging_flags});

	}
	public System.IAsyncResult Beginset_guarantee_logging_flag(string [] logprof_names,bool [] guarantee_logging_flags, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_guarantee_logging_flag", new object[] {
			logprof_names,
			guarantee_logging_flags}, callback, asyncState);
	}
	public void Endset_guarantee_logging_flag(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_local_storage_flag
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_local_storage_flag(
		string [] logprof_names,
		bool [] local_storage_flags
	) {
		this.Invoke("set_local_storage_flag", new object [] {
				logprof_names,
				local_storage_flags});

	}
	public System.IAsyncResult Beginset_local_storage_flag(string [] logprof_names,bool [] local_storage_flags, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_local_storage_flag", new object[] {
			logprof_names,
			local_storage_flags}, callback, asyncState);
	}
	public void Endset_local_storage_flag(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_logic_operation
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_logic_operation(
		string [] logprof_names,
		ASMLoggingLogicOperation [] logic_operations
	) {
		this.Invoke("set_logic_operation", new object [] {
				logprof_names,
				logic_operations});

	}
	public System.IAsyncResult Beginset_logic_operation(string [] logprof_names,ASMLoggingLogicOperation [] logic_operations, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_logic_operation", new object[] {
			logprof_names,
			logic_operations}, callback, asyncState);
	}
	public void Endset_logic_operation(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_maximum_entry_length
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_maximum_entry_length(
		string [] logprof_names,
		long [] maximum_entry_lengths
	) {
		this.Invoke("set_maximum_entry_length", new object [] {
				logprof_names,
				maximum_entry_lengths});

	}
	public System.IAsyncResult Beginset_maximum_entry_length(string [] logprof_names,long [] maximum_entry_lengths, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_maximum_entry_length", new object[] {
			logprof_names,
			maximum_entry_lengths}, callback, asyncState);
	}
	public void Endset_maximum_entry_length(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_maximum_header_size
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_maximum_header_size(
		string [] logprof_names,
		long [] maximum_header_sizes
	) {
		this.Invoke("set_maximum_header_size", new object [] {
				logprof_names,
				maximum_header_sizes});

	}
	public System.IAsyncResult Beginset_maximum_header_size(string [] logprof_names,long [] maximum_header_sizes, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_maximum_header_size", new object[] {
			logprof_names,
			maximum_header_sizes}, callback, asyncState);
	}
	public void Endset_maximum_header_size(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_maximum_query_size
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_maximum_query_size(
		string [] logprof_names,
		long [] maximum_query_sizes
	) {
		this.Invoke("set_maximum_query_size", new object [] {
				logprof_names,
				maximum_query_sizes});

	}
	public System.IAsyncResult Beginset_maximum_query_size(string [] logprof_names,long [] maximum_query_sizes, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_maximum_query_size", new object[] {
			logprof_names,
			maximum_query_sizes}, callback, asyncState);
	}
	public void Endset_maximum_query_size(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_maximum_request_size
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_maximum_request_size(
		string [] logprof_names,
		long [] maximum_request_sizes
	) {
		this.Invoke("set_maximum_request_size", new object [] {
				logprof_names,
				maximum_request_sizes});

	}
	public System.IAsyncResult Beginset_maximum_request_size(string [] logprof_names,long [] maximum_request_sizes, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_maximum_request_size", new object[] {
			logprof_names,
			maximum_request_sizes}, callback, asyncState);
	}
	public void Endset_maximum_request_size(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_remote_log_facility
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_remote_log_facility(
		string [] logprof_names,
		ASMLoggingRemoteFacility [] remote_log_facilities
	) {
		this.Invoke("set_remote_log_facility", new object [] {
				logprof_names,
				remote_log_facilities});

	}
	public System.IAsyncResult Beginset_remote_log_facility(string [] logprof_names,ASMLoggingRemoteFacility [] remote_log_facilities, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_remote_log_facility", new object[] {
			logprof_names,
			remote_log_facilities}, callback, asyncState);
	}
	public void Endset_remote_log_facility(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_remote_protocol
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_remote_protocol(
		string [] logprof_names,
		ASMLoggingRemoteProtocol [] remote_protocols
	) {
		this.Invoke("set_remote_protocol", new object [] {
				logprof_names,
				remote_protocols});

	}
	public System.IAsyncResult Beginset_remote_protocol(string [] logprof_names,ASMLoggingRemoteProtocol [] remote_protocols, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_remote_protocol", new object[] {
			logprof_names,
			remote_protocols}, callback, asyncState);
	}
	public void Endset_remote_protocol(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_remote_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_remote_server(
		string [] logprof_names,
		CommonIPPortDefinition [] ip_ports
	) {
		this.Invoke("set_remote_server", new object [] {
				logprof_names,
				ip_ports});

	}
	public System.IAsyncResult Beginset_remote_server(string [] logprof_names,CommonIPPortDefinition [] ip_ports, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_remote_server", new object[] {
			logprof_names,
			ip_ports}, callback, asyncState);
	}
	public void Endset_remote_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_remote_storage_base
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_remote_storage_base(
		string [] logprof_names,
		ASMLoggingRemoteStorageBase [] remote_storage_bases
	) {
		this.Invoke("set_remote_storage_base", new object [] {
				logprof_names,
				remote_storage_bases});

	}
	public System.IAsyncResult Beginset_remote_storage_base(string [] logprof_names,ASMLoggingRemoteStorageBase [] remote_storage_bases, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_remote_storage_base", new object[] {
			logprof_names,
			remote_storage_bases}, callback, asyncState);
	}
	public void Endset_remote_storage_base(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_report_anomalies_flag
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_report_anomalies_flag(
		string [] logprof_names,
		bool [] report_anomalies_flags
	) {
		this.Invoke("set_report_anomalies_flag", new object [] {
				logprof_names,
				report_anomalies_flags});

	}
	public System.IAsyncResult Beginset_report_anomalies_flag(string [] logprof_names,bool [] report_anomalies_flags, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_report_anomalies_flag", new object[] {
			logprof_names,
			report_anomalies_flags}, callback, asyncState);
	}
	public void Endset_report_anomalies_flag(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_request_search
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_request_search(
		string [] logprof_names,
		ASMLoggingRequestSearch [] request_searches
	) {
		this.Invoke("set_request_search", new object [] {
				logprof_names,
				request_searches});

	}
	public System.IAsyncResult Beginset_request_search(string [] logprof_names,ASMLoggingRequestSearch [] request_searches, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_request_search", new object[] {
			logprof_names,
			request_searches}, callback, asyncState);
	}
	public void Endset_request_search(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_request_type
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_request_type(
		string [] logprof_names,
		ASMLoggingRequestType [] request_types
	) {
		this.Invoke("set_request_type", new object [] {
				logprof_names,
				request_types});

	}
	public System.IAsyncResult Beginset_request_type(string [] logprof_names,ASMLoggingRequestType [] request_types, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_request_type", new object[] {
			logprof_names,
			request_types}, callback, asyncState);
	}
	public void Endset_request_type(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_search_pattern
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_search_pattern(
		string [] logprof_names,
		string [] search_patterns
	) {
		this.Invoke("set_search_pattern", new object [] {
				logprof_names,
				search_patterns});

	}
	public System.IAsyncResult Beginset_search_pattern(string [] logprof_names,string [] search_patterns, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_search_pattern", new object[] {
			logprof_names,
			search_patterns}, callback, asyncState);
	}
	public void Endset_search_pattern(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_storage_format
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:ASM/LoggingProfile",
		RequestNamespace="urn:iControl:ASM/LoggingProfile", ResponseNamespace="urn:iControl:ASM/LoggingProfile")]
	public void set_storage_format(
		string [] logprof_names,
		ASMLoggingStorageFormat [] storage_formats
	) {
		this.Invoke("set_storage_format", new object [] {
				logprof_names,
				storage_formats});

	}
	public System.IAsyncResult Beginset_storage_format(string [] logprof_names,ASMLoggingStorageFormat [] storage_formats, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_storage_format", new object[] {
			logprof_names,
			storage_formats}, callback, asyncState);
	}
	public void Endset_storage_format(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	}
	//=======================================================================
	// Enums
	//=======================================================================

	//=======================================================================
	// Structs
	//=======================================================================

}


text:
Collection of [Maven](http://maven.apache.org/) plugins that integrate with GitHub.
These plugins are built on top of [API v3](http://developer.github.com/) through the
[GitHub Java library](https://github.com/eclipse/egit-github/tree/master/org.eclipse.egit.github.core).

Released builds are available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Ccom.github.github).

## Core Configuration

The plugins support several configuration options that can either be expressed
in your project's POM file or in your `settings.xml` file. Where you put the
plugin settings depends on whether you want a specific setting to be configured
globally or on a per-project basis.

All GitHub Maven plugins support the following core configuration elements.

The notation below shows the plugin configuration property name followed
by the settings configuration property in parentheses.

* `host` (`github.global.host`)
  * Domain of GitHub API calls (defaults to `api.github.com`)
* `oauth2Token` (`github.global.oauth2Token`)
  * OAuth2 access token for API authentication
  * [More about GitHub OAuth support](http://developer.github.com/v3/oauth/)
* `userName` (`github.global.userName`)
  * GitHub user name used for API authentication
* `password` (`github.global.password`)
  * GitHub password used for API authentication
* `server` (`github.global.server`)
  * Id of the `server` element from the `settings.xml`. To use standard authentication
    set  the `username` and `password` elements in the `servers` section of your
    `settings.xml` file along with an `id`. Configure an OAuth2 token by leaving the
    `username` element blank/missing and just specify the token in the `password` element.
  * This option should be used **instead of** configuring any of `userName`, `password`
    or `oauth2Token` in the plugin `configuration` element or as a properties.
* `repositoryName`
  * Name of repository
* `repositoryOwner`
  * Owner of repository

*Note:* `repositoryOwner` property and `repositoryName` are optional and will be
inferred from the following properties if not specified

 * `project.scm.url`
 * `project.scm.connection`
 * `project.scm.developerConnection`
 * `project.url`

### Authentication Example

#### settings.xml

```xml
<servers>
  <server>
    <id>github</id>
    <username>GitHubLogin</username>
    <password>GitHubPassw0rd</password>
  </server>
</servers>
```
or
```xml
<servers>
  <server>
    <id>github</id>
    <password>OAUTH2TOKEN</password>
  </server>
</servers>
```

#### pom.xml

```xml
<properties>
  <github.global.server>github</github.global.server>
</properties>
```

## [Site Plugin](http://github.github.com/maven-plugins/site-plugin)
Maven plugin that commits files generated and updates a specific branch
reference in a GitHub repository.  This plugin can be used to deploy a created
Maven site to a `gh-pages` branch so that it can be served statically as a
GitHub Project Page.  The plugin has a `site` goal and is configured with a goal
prefix of `ghSite`.

### Configuration

* `branch`
  * Branch ref that will be updated to commit made
  * Default: `refs/heads/gh-pages`
* `message`
  * Message used for commit
* `outputDirectory`
  * Directory that includes and excludes will be relative to
  * Defaults to `siteOutputDirectory` or `project.reporting.outputDirectory`
* `includes`
  * Sub-elements will be treated as patterns to include from the
    `outputDirectory`
* `excludes`
  * Sub-elements will be treated as patterns to exclude from the
    `outputDirectory`
* `path`
  * Path relative to the root of the repository that all blobs should be
    relative to
* `force` (`github.site.force`)
  * `true` | `false` (default: `false`)
  * Whether to force a ref update, default is fast-forwards only
* `merge` (`github.site.merge`)
  * `true` | `false` (default: `false`)
  * Whether to merge with the current tree or completely replace the tree that
    the commit points to
* `dryRun` (`github.site.dryRun`)
  * `true` | `false` (default: `false`)
  * Log what blobs, tree, and commits *would* be created without actually
    creating them
* `noJekyll` (`github.site.noJekyll`)
  * `true` | `false` (default: `false`)
  * Whether to always create a `.nojekyll` file at the root of the site if one
    doesn't already exist.  This setting should be enabled if your site contains
    any folders that begin with an underscore.

### Example
```xml
<build>
  <plugins>
    <plugin>
      <groupId>com.github.github</groupId>
      <artifactId>site-maven-plugin</artifactId>
      <version>0.12</version>
      <configuration>
        <message>Creating site for ${project.version}</message>
      </configuration>
      <executions>
        <execution>
          <goals>
            <goal>site</goal>
          </goals>
          <phase>site</phase>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>
```

To commit a created site run the following command:

`$ mvn site`

# License
* [MIT License](http://www.opensource.org/licenses/mit-license.php)

redpajama_set_name: RedPajamaGithub


text:
from __future__ import unicode_literals

import django.db.models.deletion
import wagtail.wagtailcore.blocks
from django.db import migrations, models

import people.fields

class Migration(migrations.Migration):

    dependencies = [
        ('wagtailimages', '0006_add_verbose_names'),
        ('wagtailcore', '0001_squashed_0016_change_page_url_path_to_text_field'),
    ]

    operations = [
        migrations.CreateModel(
            name='ContributorPage',
            fields=[
                ('page_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='wagtailcore.Page')),
                ('first_name', models.CharField(default='', max_length=255, blank=True)),
                ('last_name', models.CharField(default='', max_length=255, blank=True)),
                ('nickname', models.CharField(default='', max_length=1024, blank=True)),
                ('email', models.EmailField(default='', max_length=254, blank=True)),
                ('twitter_handle', models.CharField(default='', max_length=16, blank=True)),
                ('short_bio', models.TextField(default='', blank=True)),
                ('long_bio', models.TextField(default='', blank=True)),
                ('headshot', models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.SET_NULL, blank=True, to='wagtailimages.Image', null=True)),
            ],
            options={
                'abstract': False,
            },
            bases=('wagtailcore.page',),
        ),
    ]


text:
package org.apache.pulsar.functions.worker.executor;

import static com.google.common.base.Preconditions.checkArgument;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyLong;
import static org.mockito.Mockito.doAnswer;
import com.google.common.util.concurrent.SettableFuture;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Delayed;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import lombok.AccessLevel;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.bookkeeper.common.concurrent.FutureUtils;
import org.mockito.stubbing.Answer;

/**
 * A mocked scheduled executor that records scheduled tasks and executes them when the clock is
 * advanced past their execution time.
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PUBLIC)
public class MockExecutorController {

    @Data
    private class DeferredTask implements ScheduledFuture<Void> {

        private final Runnable runnable;
        private final long scheduledAtMillis;
        @Getter
        private final CompletableFuture<Void> future;

        public DeferredTask(Runnable runnable,
                            long delayTimeMs) {
            this.runnable = runnable;
            this.scheduledAtMillis = delayTimeMs + clock.millis();
            this.future = FutureUtils.createFuture();
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(scheduledAtMillis - clock.millis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return Long.compare(getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS));
        }

        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            return future.cancel(mayInterruptIfRunning);
        }

        @Override
        public boolean isCancelled() {
            return future.isCancelled();
        }

        @Override
        public boolean isDone() {
            return future.isDone();
        }

        @Override
        public Void get() throws InterruptedException, ExecutionException {
            future.get();
            return null;
        }

        @Override
        public Void get(long timeout, TimeUnit unit)
                throws InterruptedException, ExecutionException, TimeoutException {
            future.get(timeout, unit);
            return null;
        }

        void run() {
            runnable.run();
            FutureUtils.complete(future, null);
        }

    }

    @Getter
    private final MockClock clock = new MockClock();
    private final List<DeferredTask> deferredTasks = new ArrayList<>();

    public MockExecutorController controlSubmit(ScheduledExecutorService service) {
        doAnswer(answerNow()).when(service).submit(any(Runnable.class));
        return this;
    }

    public MockExecutorController controlExecute(ScheduledExecutorService service) {
        doAnswer(answerNow()).when(service).execute(any(Runnable.class));
        return this;
    }

    public MockExecutorController controlSchedule(ScheduledExecutorService service) {
        doAnswer(answerDelay(this)).when(service).schedule(any(Runnable.class), anyLong(), any(TimeUnit.class));
        return this;
    }

    public MockExecutorController controlScheduleAtFixedRate(ScheduledExecutorService service,
                                                             int maxInvocations) {
        doAnswer(answerAtFixedRate(this, maxInvocations))
            .when(service)
            .scheduleAtFixedRate(any(Runnable.class), anyLong(), anyLong(), any(TimeUnit.class));
        return this;
    }

    private static Answer<ScheduledFuture<?>> answerAtFixedRate(MockExecutorController controller, int numTimes) {
        return invocationOnMock -> {
            Runnable task = invocationOnMock.getArgument(0);
            long initialDelay = invocationOnMock.getArgument(1);
            long delay = invocationOnMock.getArgument(2);
            TimeUnit unit = invocationOnMock.getArgument(3);

            DeferredTask deferredTask = null;
            for (int i = 0; i < numTimes; i++) {
                long delayMs = unit.toMillis(initialDelay) + i * unit.toMillis(delay);

                deferredTask = controller.addDelayedTask(
                    controller,
                    delayMs,
                    task);
            }
            return deferredTask;
        };
    }

    private static Answer<ScheduledFuture<?>> answerDelay(MockExecutorController executor) {
        return invocationOnMock -> {

           Runnable task = invocationOnMock.getArgument(0);
           long value = invocationOnMock.getArgument(1);
           TimeUnit unit = invocationOnMock.getArgument(2);
           DeferredTask deferredTask = executor.addDelayedTask(executor, unit.toMillis(value), task);
           if (value <= 0) {
               task.run();
               FutureUtils.complete(deferredTask.future, null);
           }
           return deferredTask;
       };
    }

    private static Answer<Future<?>> answerNow() {
        return invocationOnMock -> {

           Runnable task = invocationOnMock.getArgument(0);
           task.run();
           SettableFuture<Void> future = SettableFuture.create();
           future.set(null);
           return future;
       };
    }

    private DeferredTask addDelayedTask(
            MockExecutorController executor,
            long delayTimeMs,
            Runnable task) {
        checkArgument(delayTimeMs >= 0);
        DeferredTask deferredTask = new DeferredTask(task, delayTimeMs);
        executor.deferredTasks.add(deferredTask);
        return deferredTask;
    }

    public void advance(Duration duration) {
        clock.advance(duration);
        Iterator<DeferredTask> entries = deferredTasks.iterator();
        List<DeferredTask> toExecute = new ArrayList<>();
        while (entries.hasNext()) {
            DeferredTask next = entries.next();
            if (next.getDelay(TimeUnit.MILLISECONDS) <= 0) {
                entries.remove();
                toExecute.add(next);
            }
        }
        for (DeferredTask task : toExecute) {
            task.run();
        }
    }

}


text:
using namespace VertexAsylum;

vaLog::vaLog( )
{
    m_lastAddedTime = 0;

    m_timer.Start();

    if( !m_outStream.Open( vaCore::GetExecutableDirectory( ) + L"log.txt", FileCreationMode::Create, FileAccessMode::Write, FileShareMode::Read ) )
    {
        // where does one log failure to open the log file?
        vaCore::DebugOutput( L"Unable to open log output file" );
    }
    else
    {
        // Using byte order marks: https://msdn.microsoft.com/en-us/library/windows/desktop/dd374101
        uint16 utf16LE = 0xFEFF;
        m_outStream.WriteValue<uint16>(utf16LE);
    }
}

vaLog::~vaLog( )
{
    m_timer.Stop();

    m_outStream.Close();
}

void vaLog::Add( const vaVector4 & color, const std::wstring & text )
{
    vaCore::DebugOutput( L"vaLog: " + text + L"\n" );

    {
        vaCriticalSectionScopeLock lock( m_criticalSection );

        time_t locTime = time( NULL );
        double now = m_timer.GetCurrentTimeDouble( );
        assert( now >= m_lastAddedTime );
        if( now > m_lastAddedTime )
            m_lastAddedTime = now;
        m_logEntries.push_back( Entry( color, text, locTime, m_lastAddedTime ) );

        if( m_outStream.IsOpen() )
        {
            char buff[64];
#pragma warning ( suppress: 4996 )
            strftime( buff, sizeof( buff ), "%H:%M:%S: ", localtime( &locTime ) );

            m_outStream.WriteTXT( vaStringTools::SimpleWiden(buff) + text + L"\r\n" );
        }
    }
}

void vaLog::Add( const char * messageFormat, ... )
{
    va_list args;
    va_start( args, messageFormat );
    std::string txt = vaStringTools::Format( messageFormat, args );
    va_end( args );

    Add( vaVector4( 0.0, 0.0, 0.0, 1.0 ), vaStringTools::SimpleWiden(txt) );
}

void vaLog::Add( const wchar_t * messageFormat, ... )
{
    va_list args;
    va_start( args, messageFormat );
    std::wstring txt = vaStringTools::Format( messageFormat, args );
    va_end( args );

    Add( vaVector4( 0.0, 0.0, 0.0, 1.0 ), txt );
}

void vaLog::Add( const vaVector4 & color, const char * messageFormat, ... )
{
    va_list args;
    va_start( args, messageFormat );
    std::string txt = vaStringTools::Format( messageFormat, args );
    va_end( args );

    Add( color, vaStringTools::SimpleWiden( txt ) );
}

void vaLog::Add( const vaVector4 & color, const wchar_t * messageFormat, ... )
{
    va_list args;
    va_start( args, messageFormat );
    std::wstring txt = vaStringTools::Format( messageFormat, args );
    va_end( args );

    Add( color, txt );
}

int vaLog::FindNewest( float maxAgeSeconds )
{
    vaCriticalSectionScopeLock lock( m_criticalSection );

    double now = m_timer.GetCurrentTimeDouble( );
    double searchTime = now - (double)maxAgeSeconds;

    assert( now >= m_lastAddedTime );

    // nothing to return?
    if( m_logEntries.back().SystemTime < searchTime )
        return (int)m_logEntries.size();

    // return all?
    if( m_logEntries.front( ).SystemTime >= searchTime )
        return 0;

    int currentIndex    = (int)m_logEntries.size()-1;
    int prevStepIndex   = currentIndex;
    int stepSize        = vaMath::Max( 1, currentIndex / 100 );
    while( true )
    {
        assert( m_logEntries[prevStepIndex].SystemTime >= searchTime );

        currentIndex = vaMath::Max( 0, prevStepIndex - stepSize );

        if( m_logEntries[currentIndex].SystemTime < searchTime )
        {
            if( stepSize == 1 )
                return currentIndex+1;
            currentIndex = prevStepIndex + stepSize;
            stepSize = (stepSize+1) / 2;
        }
        else
        {
            prevStepIndex = currentIndex;
        }
    }

    // shouldn't ever happen!
    assert( false );
    return -1;
}


text:
		<link rel="stylesheet" href="css.css" type="text/css" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
		<meta property="og:site_name" content="Genium Tech"/>
		<meta property="og:title" content="Diffentiating Short A and I"/>
		<meta property="og:description" content="Differentiating Short A and I Game"/>
		<meta property="og:image" content="http://geniumtech.com/diffentiatingshortaandi/cover.png"/>
		<meta property="og:url" content="http://geniumtech.com/diffentiatingshortaandi/index.html"/>
		<meta property="og:type" content="article"/>

 Press

 to begin


text:
maintainer       'Jason Boyles'
maintainer_email 'jason.boyles@rackspace.com'
license          'Apache 2.0'
description      'install packages for mongo'
long_description IO.read(File.join(File.dirname(__FILE__), 'README.md'))
version          '0.0.1'
name             'install_packages'


text:
Gabbi Tester
============

Runs telemetry tests against the OpenStack cloud.

Required arguments
------------------

* ``--openstack-version``: The version of the OpenStack installed.
    That option also defines the list of tests to run against the OpenStack.
* ``--openstackrc``: The `OpenStack RC <http://docs.openstack.org/user-guide/common/cli-set-environment-variables-using-openstack-rc.html>`_ file.
    The absolute and relative paths to the file are supported.  When this option is not provided, `infrared` will try to use the `keystonerc` file from the active workspace.
    The openstackrc file is copied to the tester station and used to run tests
* ``--undercloudrc``: The undercloud RC file.
    The absolute and relative paths to the file are supported.  When this option is not provided, `infrared` will try to use the `stackrc` file from the active workspace.

Optional arguments
------------------
* ``--network``: Network settings to use.
  Default network configuration includes the ``protocol`` (ipv4 or ipv6) and ``interfaces`` sections::

    network:
        protocol: ipv4
        interfaces:
            - net: management
              name: eth1
            - net: external
              name: eth2

* ``--setup``: The setup variables, such as git repo name, folders to use on tester and others::

    setup:
        repo_dest: ~/TelemetryGabbits
        gabbi_venv: ~/gbr
        gabbits_repo: <private-repo-url>

Gabbi results
-------------

`infrared` fetches all the  output files, like results to the ``gabbi_results`` folder under the active `workspace <workspace.html>`_ folder.


text:
require 'rubygems/test_case'

unless defined?(OpenSSL::SSL)
  warn 'Skipping Gem::Security::Signer tests.  openssl not found.'
end

class TestGemSecuritySigner < Gem::TestCase

  ALTERNATE_KEY  = load_key 'alternate'
  CHILD_KEY      = load_key 'child'
  GRANDCHILD_KEY = load_key 'grandchild'

  CHILD_CERT      = load_cert 'child'
  GRANDCHILD_CERT = load_cert 'grandchild'
  EXPIRED_CERT    = load_cert 'expired'

  def setup
    super

    @cert_file = PUBLIC_CERT
  end

  def test_initialize
    signer = Gem::Security::Signer.new nil, nil

    assert_nil signer.key
    assert_nil signer.cert_chain
  end

  def test_initialize_cert_chain_empty
    signer = Gem::Security::Signer.new PUBLIC_KEY, []

    assert_empty signer.cert_chain
  end

  def test_initialize_cert_chain_mixed
    signer = Gem::Security::Signer.new nil, [@cert_file, CHILD_CERT]

    assert_equal [PUBLIC_CERT, CHILD_CERT].map { |c| c.to_pem },
                 signer.cert_chain.map { |c| c.to_pem }
  end

  def test_initialize_cert_chain_invalid
    assert_raises OpenSSL::X509::CertificateError do
      Gem::Security::Signer.new nil, ['garbage']
    end
  end

  def test_initialize_cert_chain_path
    signer = Gem::Security::Signer.new nil, [@cert_file]

    assert_equal [PUBLIC_CERT].map { |c| c.to_pem },
                 signer.cert_chain.map { |c| c.to_pem }
  end

  def test_initialize_default
    FileUtils.mkdir_p File.join(Gem.user_home, '.gem')

    private_key_path = File.join Gem.user_home, '.gem', 'gem-private_key.pem'
    Gem::Security.write PRIVATE_KEY, private_key_path

    public_cert_path = File.join Gem.user_home, '.gem', 'gem-public_cert.pem'
    Gem::Security.write PUBLIC_CERT, public_cert_path

    signer = Gem::Security::Signer.new nil, nil

    assert_equal PRIVATE_KEY.to_pem, signer.key.to_pem
    assert_equal [PUBLIC_CERT.to_pem], signer.cert_chain.map { |c| c.to_pem }
  end

  def test_initialize_key_path
    key_file = PRIVATE_KEY_PATH

    signer = Gem::Security::Signer.new key_file, nil

    assert_equal PRIVATE_KEY.to_s, signer.key.to_s
  end

  def test_initialize_encrypted_key_path
    key_file = ENCRYPTED_PRIVATE_KEY_PATH

    signer = Gem::Security::Signer.new key_file, nil, PRIVATE_KEY_PASSPHRASE

    assert_equal ENCRYPTED_PRIVATE_KEY.to_s, signer.key.to_s
  end

  def test_extract_name
    signer = Gem::Security::Signer.new nil, nil

    assert_equal 'child@example', signer.extract_name(CHILD_CERT)
  end

  def test_load_cert_chain
    Gem::Security.trust_dir.trust_cert PUBLIC_CERT

    signer = Gem::Security::Signer.new nil, []
    signer.cert_chain.replace [CHILD_CERT]

    signer.load_cert_chain

    assert_equal [PUBLIC_CERT.to_pem, CHILD_CERT.to_pem],
                 signer.cert_chain.map { |c| c.to_pem }
  end

  def test_load_cert_chain_broken
    Gem::Security.trust_dir.trust_cert CHILD_CERT

    signer = Gem::Security::Signer.new nil, []
    signer.cert_chain.replace [GRANDCHILD_CERT]

    signer.load_cert_chain

    assert_equal [CHILD_CERT.to_pem, GRANDCHILD_CERT.to_pem],
                 signer.cert_chain.map { |c| c.to_pem }
  end

  def test_sign
    signer = Gem::Security::Signer.new PRIVATE_KEY, [PUBLIC_CERT]

    signature = signer.sign 'hello'

    expected = <<-EXPECTED
cHze2sEfRysoUMCfGVAx/7o8jxj5liJJ2ptNxe2jf3l+EZvyjdqpXo9Ndzxx
6xLp2rxLG4K2//ip4aCH5Sh7hnia+F5u6iuLBETPlklPrmw5dnuKZxolz+vM
0O1aOZsQHcVzQoESTGjkms3KZk+gn3lg0sSBbAV5/LyDYoHCEjxlcA5D+Olb
rDmRyBMOnMS+q489OZ5Hr6B2YJJ3QbUwIZNhUeNmOxIBEYTrrKkZ92qkxbRN
qhlqFP4jR6zXFeyBCOr0KpTiWBNuxBFXDsxmhGyt2BOIjD6qmKn7RSIfYg/U
toqvglr0kdbknSRRjBVLK6tsgr07aLT9gNP7mTW2PA==
    EXPECTED

    assert_equal expected, [signature].pack('m')
  end

  def test_sign_expired
    signer = Gem::Security::Signer.new PRIVATE_KEY, [EXPIRED_CERT]

    e = assert_raises Gem::Security::Exception do
      signer.sign 'hello'
    end

    assert_match "certificate /CN=nobody/DC=example not valid after 1970-01-01 00:00:00 UTC", e.message
  end

  def test_sign_expired_auto_update
    skip if Gem.java_platform?
    FileUtils.mkdir_p File.join(Gem.user_home, '.gem'), :mode => 0700

    private_key_path = File.join(Gem.user_home, '.gem', 'gem-private_key.pem')
    Gem::Security.write PRIVATE_KEY, private_key_path

    cert_path = File.join Gem.user_home, '.gem', 'gem-public_cert.pem'
    Gem::Security.write EXPIRED_CERT, cert_path

    signer = Gem::Security::Signer.new PRIVATE_KEY, [EXPIRED_CERT]

    signer.sign 'hello'

    cert = OpenSSL::X509::Certificate.new File.read cert_path

    refute_equal EXPIRED_CERT.to_pem, cert.to_pem
    assert_in_delta Time.now,         cert.not_before, 10

    expiry = EXPIRED_CERT.not_after.strftime "%Y%m%d%H%M%S"

    expired_path =
      File.join Gem.user_home, '.gem', "gem-public_cert.pem.expired.#{expiry}"

    assert_path_exists expired_path
    assert_equal EXPIRED_CERT.to_pem, File.read(expired_path)
  end

  def test_sign_expired_auto_update_exists
    FileUtils.mkdir_p File.join(Gem.user_home, '.gem'), :mode => 0700

    expiry = EXPIRED_CERT.not_after.strftime "%Y%m%d%H%M%S"
    expired_path =
      File.join Gem.user_home, "gem-public_cert.pem.expired.#{expiry}"

    Gem::Security.write EXPIRED_CERT, expired_path

    private_key_path = File.join(Gem.user_home, 'gem-private_key.pem')
    Gem::Security.write PRIVATE_KEY, private_key_path

    cert_path = File.join Gem.user_home, 'gem-public_cert.pem'
    Gem::Security.write EXPIRED_CERT, cert_path

    signer = Gem::Security::Signer.new PRIVATE_KEY, [EXPIRED_CERT]

    e = assert_raises Gem::Security::Exception do
      signer.sign 'hello'
    end

    assert_match %r%certificate /CN=nobody/DC=example not valid%, e.message
  end

  def test_sign_no_key
    signer = Gem::Security::Signer.new nil, nil

    assert_nil signer.sign 'stuff'
  end

  def test_sign_wrong_key
    signer = Gem::Security::Signer.new ALTERNATE_KEY, [PUBLIC_CERT]

    assert_raises Gem::Security::Exception do
      signer.sign 'hello'
    end
  end

  def test_sign_no_certs
    signer = Gem::Security::Signer.new ALTERNATE_KEY, []

    assert_raises Gem::Security::Exception do
      signer.sign 'hello'
    end
  end

end if defined?(OpenSSL::SSL)


text:
verify_installed_or_exit() {
  # https://stackoverflow.com/questions/592620/how-can-i-check-if-a-program-exists-from-a-bash-script#677212
  command -v $1 >/dev/null 2>&1 || { echo >&2 "Please install $1 to run this script.  Aborting."; exit 1; }
}

verify_installed_or_exit node
verify_installed_or_exit pm2
verify_installed_or_exit tracerbench
HAR_REMIX_SCRIPT="bin/relationship-performance-tracking/src/har-remix.js"
WORKSPACE="relationship-performance-test-app"
TEST_APP_PATH="packages/unpublished-relationship-performance-test-app"
INITIAL_BRANCH=$(git rev-parse --symbolic-full-name --abbrev-ref HEAD)

if [[ -z "$USE_EXISTING_DISTS" ]]; then
  echo "Creating production builds for commits"
  if [[ -z "$CONTROL_COMMIT" ]]; then
    echo "Set the CONTROL_COMMIT env variable."
    return 1
  fi

  if [[ -z "$EXPERIMENT_COMMIT" ]]; then
    echo "Set the EXPERIMENT_COMMIT env variable."
    return 1
  fi

  echo "Checking out control $CONTROL_COMMIT"
  git checkout $CONTROL_COMMIT
  yarn install
  yarn workspace $WORKSPACE ember build -e production --output-path dist-control
  echo "Checking out experiment $EXPERIMENT_COMMIT"
  git checkout $EXPERIMENT_COMMIT
  yarn install
  yarn workspace $WORKSPACE ember build -e production --output-path dist-experiment
fi

HR_PORT=4200 HR_GROUP=control pm2 start $HAR_REMIX_SCRIPT --name control
HR_PORT=4201 HR_GROUP=experiment pm2 start $HAR_REMIX_SCRIPT --name experiment
node ./bin/relationship-performance-tracking/src/tracerbench.js
for result in "$TEST_APP_PATH"/tracerbench-results/*-trace-results.json; do
  echo
  echo ===============================================================================
  echo Processing $(basename ${result} -trace-results.json)
  tracerbench compare:analyze "${result}";
done
pm2 kill
git checkout "$INITIAL_BRANCH"


text:
package OOPMethods;

/**
 * Created by beatriceotugo on 06/07/2017.
 */
public class Focus {
}


text:
import { IterableX } from '../../iterable';
import { ofEntries as ofEntriesStatic } from '../../iterable/ofentries';

IterableX.ofEntries = ofEntriesStatic;

declare module '../../iterable' {
  namespace IterableX {
    export let ofEntries: typeof ofEntriesStatic;
  }
}


text:
define([
  'angular',
  'underscore',
  'jquery'
],
function (angular, _, $) {
  'use strict';

  // This function needs $inject annotations, update below
  // when changing arguments to this function
  function PanelBaseCtrl($scope, $rootScope, $timeout) {

    var menu = [
      {
        text: 'Edit',
        configModal: "app/partials/paneleditor.html",
        condition: !$scope.panelMeta.fullscreenEdit
      },
      {
        text: 'Edit',
        click: "toggleFullscreenEdit()",
        condition: $scope.panelMeta.fullscreenEdit
      },
      {
        text: "Fullscreen",
        click: 'toggleFullscreen()',
        condition: $scope.panelMeta.fullscreenView
      },
      {
        text: 'Duplicate',
        click: 'duplicatePanel(panel)',
        condition: true
      },
      {
        text: 'Span',
        submenu: [
          { text: '1', click: 'updateColumnSpan(1)' },
          { text: '2', click: 'updateColumnSpan(2)' },
          { text: '3', click: 'updateColumnSpan(3)' },
          { text: '4', click: 'updateColumnSpan(4)' },
          { text: '5', click: 'updateColumnSpan(5)' },
          { text: '6', click: 'updateColumnSpan(6)' },
          { text: '7', click: 'updateColumnSpan(7)' },
          { text: '8', click: 'updateColumnSpan(8)' },
          { text: '9', click: 'updateColumnSpan(9)' },
          { text: '10', click: 'updateColumnSpan(10)' },
          { text: '11', click: 'updateColumnSpan(11)' },
          { text: '12', click: 'updateColumnSpan(12)' },
        ],
        condition: true
      },
      {
        text: 'Remove',
        click: 'remove_panel_from_row(row, panel)',
        condition: true
      }
    ];

    $scope.inspector = {};
    $scope.panelMeta.menu = _.where(menu, { condition: true });

    $scope.updateColumnSpan = function(span) {
      $scope.panel.span = span;

      $timeout(function() {
        $scope.$emit('render');
      });
    };

    $scope.enterFullscreenMode = function(options) {
      var docHeight = $(window).height();
      var editHeight = Math.floor(docHeight * 0.3);
      var fullscreenHeight = Math.floor(docHeight * 0.7);
      var oldTimeRange = $scope.range;

      $scope.height = options.edit ? editHeight : fullscreenHeight;
      $scope.editMode = options.edit;

      if (!$scope.fullscreen) {
        var closeEditMode = $rootScope.$on('panel-fullscreen-exit', function() {
          $scope.editMode = false;
          $scope.fullscreen = false;
          delete $scope.height;

          closeEditMode();

          $timeout(function() {
            if (oldTimeRange !== $scope.range) {
              $scope.dashboard.refresh();
            }
            else {
              $scope.$emit('render');
            }
          });
        });
      }

      $(window).scrollTop(0);

      $scope.fullscreen = true;

      $rootScope.$emit('panel-fullscreen-enter');

      $timeout(function() {
        $scope.$emit('render');
      });

    };

    $scope.toggleFullscreenEdit = function() {
      if ($scope.editMode) {
        $rootScope.$emit('panel-fullscreen-exit');
        return;
      }

      $scope.enterFullscreenMode({edit: true});
    };

    $scope.toggleFullscreen = function() {
      if ($scope.fullscreen && !$scope.editMode) {
        $rootScope.$emit('panel-fullscreen-exit');
        return;
      }

      $scope.enterFullscreenMode({ edit: false });
    };

  }

  PanelBaseCtrl['$inject'] = ['$scope', '$rootScope', '$timeout'];

  return PanelBaseCtrl;

});


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Appalachia 3: 251 (1884)

#### Original name
Ramularia oxalidis Farl.

### Remarks
null


text:
using System.Collections;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using JudoPayDotNet;
using JudoPayDotNet.Http;
using JudoPayDotNet.Models;
using JudoPayDotNetDotNet.Logging;
using NSubstitute;
using NUnit.Framework;

namespace JudoPayDotNetTests.Clients
{
    [TestFixture]
    public class ThreeDsTests
    {
        //Test data
        private class ThreeDCaseSources
        {
            public static IEnumerable GetSuccessTestCases
            {
                get
                {
                    yield return new TestCaseData("42353vd22",
                        @"{
                            receiptId : '134567',
                            result : 'the result',
                            message : 'a message',
                            acsUrl : '12456',
                            md : '1312453252352366647',
                            paReq : 'pa request',
                        }").SetName("GetThreeDsAuthorizationsWithSuccess");
                }
            }

            public static IEnumerable GetFailureTestCases
            {
                get
                {
                    yield return new TestCaseData("34254645gvdv3",
                        @"
                        {
                            errorMessage : 'ThreeDSecureNotSuccessful',
                            errorType : '9'
                        }").SetName("GetThreeDsAuthorizationsWithoutSuccess");
                }
            }

            public static IEnumerable CompleteSuccessTestCases
            {
                get
                {
                    yield return new TestCaseData("42353vd22",
                        new ThreeDResultModel
                        {
                            PaRes = "134253623AbE3442"
                        },
                         @"{
                            receiptId : '134567',
                            type : 'Create',
                            judoId : '12456',
                            originalAmount : 20,
                            amount : 20,
                            netAmount : 20,
                            cardDetails :
                                {
                                    cardLastfour : '1345',
                                    endDate : '1214',
                                    cardToken : 'ASb345AE',
                                    cardType : 'VISA'
                                },
                            currency : 'GBP',
                            consumer :
                                {
                                    consumerToken : 'B245SEB',
                                    yourConsumerReference : 'Consumer1'
                                },
                            threeDSecure :
                                {
                                    attempted : true,
                                    result : 'done'
                                }
                            }").SetName("CompleteThreeDsAuthorizationsWithSuccess");
                }
            }

            public static IEnumerable CompleteFailureTestCases
            {
                get
                {
                    yield return new TestCaseData("42353vd22",
                        new ThreeDResultModel
                        {
                            PaRes = "134253623AbE3442"
                        },@"
                        {
                            errorMessage : 'ThreeDSecureNotSuccessful',
                            errorType : '9'
                        }").SetName("CompleteThreeDsAuthorizationsWithoutSuccess");
                }
            }
        }

        [Test, TestCaseSource(typeof(ThreeDCaseSources), "GetSuccessTestCases")]
        public void GetThreeDsAuthorizationsWithSuccess(string md, string responseData)
        {
            var httpClient = Substitute.For<IHttpClient>();
            var response = new HttpResponseMessage(HttpStatusCode.OK) {Content = new StringContent(responseData)};
            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var responseTask = new TaskCompletionSource<HttpResponseMessage>();
            responseTask.SetResult(response);

            httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(responseTask.Task);

            var client = new Client(new Connection(httpClient,
                                                    DotNetLoggerFactory.Create,
                                                    "http://judo.com"));

            var judo = new JudoPayApi(DotNetLoggerFactory.Create, client);

            var paymentRequiresThreeD =
                                            judo.ThreeDs.GetThreeDAuthorization(md).Result;

            Assert.NotNull(paymentRequiresThreeD);
            Assert.IsFalse(paymentRequiresThreeD.HasError);
            Assert.NotNull(paymentRequiresThreeD.Response);
            Assert.AreEqual(paymentRequiresThreeD.Response.ReceiptId, "134567");
        }

        [Test, TestCaseSource(typeof(ThreeDCaseSources), "GetFailureTestCases")]
        public void GetThreeDsAuthorizationsFail(string md, string responseData)
        {
            var httpClient = Substitute.For<IHttpClient>();
            var response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content = new StringContent(responseData)
            };
            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var responseTask = new TaskCompletionSource<HttpResponseMessage>();
            responseTask.SetResult(response);

            httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(responseTask.Task);

            var client = new Client(new Connection(httpClient,
                                                    DotNetLoggerFactory.Create,
                                                    "http://judo.com"));

            var judo = new JudoPayApi(DotNetLoggerFactory.Create, client);

            var paymentReceiptResult =
                                judo.ThreeDs.GetThreeDAuthorization(md).Result;

            Assert.NotNull(paymentReceiptResult);
            Assert.IsTrue(paymentReceiptResult.HasError);
        }

        [Test, TestCaseSource(typeof(ThreeDCaseSources), "CompleteSuccessTestCases")]
        public void CompleteThreeDsWithSuccess(string receiptId, ThreeDResultModel threeDResult,
                                                string responseData)
        {
            var httpClient = Substitute.For<IHttpClient>();
            var response = new HttpResponseMessage(HttpStatusCode.OK) {Content = new StringContent(responseData)};
            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var responseTask = new TaskCompletionSource<HttpResponseMessage>();
            responseTask.SetResult(response);

            httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(responseTask.Task);

            var client = new Client(new Connection(httpClient,
                                                    DotNetLoggerFactory.Create,
                                                    "http://judo.com"));

            var judo = new JudoPayApi(DotNetLoggerFactory.Create, client);

            var paymentReceiptResult =
                                judo.ThreeDs.Complete3DSecure(receiptId, threeDResult).Result;

            Assert.NotNull(paymentReceiptResult);
            Assert.IsFalse(paymentReceiptResult.HasError);
            Assert.NotNull(paymentReceiptResult.Response);
            Assert.AreEqual(paymentReceiptResult.Response.ReceiptId, "134567");
            Assert.AreEqual(paymentReceiptResult.Response.ThreeDSecure.Result, "done");
        }

        [Test, TestCaseSource(typeof(ThreeDCaseSources), "CompleteFailureTestCases")]
        public void CompleteThreeDsFail(string receiptId, ThreeDResultModel threeDResult,
                                                string responseData)
        {
            var httpClient = Substitute.For<IHttpClient>();
            var response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content = new StringContent(responseData)
            };
            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            var responseTask = new TaskCompletionSource<HttpResponseMessage>();
            responseTask.SetResult(response);

            httpClient.SendAsync(Arg.Any<HttpRequestMessage>()).Returns(responseTask.Task);

            var client = new Client(new Connection(httpClient,
                                                    DotNetLoggerFactory.Create,
                                                    "http://judo.com"));

            var judo = new JudoPayApi(DotNetLoggerFactory.Create, client);

            var paymentReceiptResult =
                                judo.ThreeDs.Complete3DSecure(receiptId, threeDResult).Result;

            Assert.NotNull(paymentReceiptResult);
            Assert.IsTrue(paymentReceiptResult.HasError);
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace HeathcareSystem.BindingModels
{
    public class RequestingRecord
    {
        public int PatientId { get; set; }
        public List<int> DiseaseIds { get; set; }
        public int RecordId { get; set; }
    }

    public class CreateRecordBindingModel
    {
        public int AppointmentId { get; set; }
    }
}


text:
uintptr_t __stack_chk_guard = STACK_CHK_GUARD;

__attribute__((noreturn)) extern "C" void __stack_chk_fail(void) {
    kputs("Stack smashed!");
    while (true) {
    }
}


text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');
error_reporting(0);
ini_set("display_errors", 0 );

?>
<!DOCTYPE html>

        <title>CCB - Usuários</title>
        <meta charset="utf-8">
        <link href="<?= base_url('assets/css/bootstrap-responsive.css');?>" rel="stylesheet" media="screen">
        <link href="<?= base_url('assets/css/bootstrap-responsive.min.css');?>" rel="stylesheet" media="screen">
        <link href="<?= base_url('assets/css/bootstrap.css');?>" rel="stylesheet" media="screen">
        <link href="<?= base_url('assets/css/bootstrap.min.css');?>" rel="stylesheet" media="screen">
        <link href="<?= base_url('assets/css/codeigniter.css');?>" rel="stylesheet" media="screen">
        <link href="<?= base_url('assets/css/font-awesome.min.css');?>" rel="stylesheet" media="screen">

Usuários do Sistema

                    Situação
                    Nome
                    Nome de usuário
                    Telefone
                    Ações

                <?php foreach ($users as $user){ ?>

                            <?php if($user->role == 1){ ?>
                                <img title="Administrador" src="<?= base_url('assets/img/icon/role_super.png'); ?>" class="img-responsive" height="17" width="17">
                            <?php }else{ ?>
                                <img title="Atendimento" src="<?= base_url('assets/img/icon/role_user.png'); ?>" class="img-responsive" height="17" width="17">
                            <?php } ?>
                            <?php if($user->status == 1){ ?>
                                <img title="Ativo" src="<?= base_url('assets/img/icon/active.png'); ?>" class="img-responsive" height="17" width="17">
                            <?php }else{ ?>
                                <img title="Inativo" src="<?= base_url('assets/img/icon/inactive.png'); ?>" class="img-responsive" height="17" width="17">
                            <?php } ?>

                        <?php echo $user->name; ?>
                        <?php echo $user->username; ?>
                        <?php echo $user->phone; ?>

                            <a href="<?= base_url('user/changestat/'.$user->id); ?>">
                                <?php if($user->status == 1){ ?>
                                <img title="Desativar" src="<?= base_url('assets/img/icon/disable.png'); ?>" class="img-responsive" height="17" width="17" onclick="return confirm('Desativar um usuário vai impossibilitar que o mesmo possa se logar no sistema.');">
                                <?php }else{ ?>
                                    <img title="Ativar" src="<?= base_url('assets/img/icon/disable.png'); ?>" class="img-responsive" height="17" width="17" onclick="return confirm('Ativar um usuário vai possibilitar que o mesmo possa se logar no sistema.');">
                                <?php } ?>

                            <a href="<?= base_url('user/edit/'.$user->id); ?>">
                                <img title="Editar" src="<?= base_url('assets/img/icon/edit.png'); ?>" class="img-responsive" height="17" width="17">

                            <a href="<?= base_url('user/delete/'.$user->id); ?>">
                                <img title="Remover" src="<?= base_url('assets/img/icon/remove.png'); ?>" class="img-responsive" height="13" width="13" onclick="return confirm('Tem certeza que deseja fazer isto? Remover um usuário vai apagar todos os registros dele no sistema.');">

                <?php } ?>

        <a class="btn btn-primary" href="<?= base_url();?>user/newuser">Novo usuário

        <?php if ($savesuccess != null) { if ($savesuccess['id'] == '1'){?>

            <?php }else{ if ($savesuccess['id'] == '2'){?>

            <?php }else{ if ($savesuccess['id'] == '3'){?>

            <?php }else{ ?>

            <?php }}}} ?>


text:
Spree::Core::Engine.routes.prepend do
  namespace :admin do
    resources :users do
      member do
        put :generate_api_key
        put :clear_api_key
      end
    end
  end

  namespace :api, :defaults => { :format => 'json' } do
    resources :products do
      resources :variants
      resources :product_properties
    end

    resources :images
    resources :checkouts do
      member do
        put :next
      end
    end

    resources :variants, :only => [:index] do
    end

    resources :option_types do
      resources :option_values
    end

    resources :orders do
      resources :return_authorizations
      member do
        put :address
        put :delivery
        put :cancel
        put :empty
      end

      resources :line_items
      resources :payments do
        member do
          put :authorize
          put :capture
          put :purchase
          put :void
          put :credit
        end
      end

      resources :shipments, :only => [:create, :update] do
        member do
          put :ready
          put :ship
          put :add
          put :remove
        end
      end
    end

    resources :zones
    resources :countries, :only => [:index, :show]
    resources :states,    :only => [:index, :show]
    resources :addresses, :only => [:show, :update]

    resources :taxonomies do
      member do
        get :jstree
      end
      resources :taxons do
        member do
          get :jstree
        end
      end
    end
    resources :taxons, :only => [:index]
    resources :inventory_units, :only => [:show, :update]
    resources :users
    resources :properties
    resources :stock_locations do
      resources :stock_movements
      resources :stock_items
    end
  end
end


text:
package ls.output.html;

import java.io.IOException;
import java.io.Writer;

import ls.http.common.CompositeWritable;
import ls.http.common.Writable;
import ls.http.response.HttpContent;

public class Html implements HttpContent {

    private Writable _content;

    protected Html(Writable... cs) {
        _content = new CompositeWritable(cs);
    }

    @Override
    public void writeTo(Writer w) throws IOException {
        _content.writeTo(w);
    }

    @Override
    public String getMediaType() {
        return "text/html";
    }

    public static Writable text(String s) { return new HtmlText(s);}
    public static Writable text(int i) { return new HtmlText(Integer.toString(i));}
    public static Writable h1(Writable... c) { return new HtmlElem("h1",c);}
    public static Writable h2(Writable... c) { return new HtmlElem("h2",c);}
    public static Writable h3(Writable... c) { return new HtmlElem("h3",c);}
    public static Writable form(String method, String url, Writable... c) {
        return new HtmlElem("form",c)
            .withAttr("method", method)
            .withAttr("action", url);
    }
    public static Writable label(String to, String text) {
        return new HtmlElem("label", new HtmlText(text))
            .withAttr("for", to);
    }
    public static Writable textInput(String name) {
        return new HtmlElem("input")
            .withAttr("type", "text")
            .withAttr("name", name);
    }
    public static Writable input(String name,String type) {
        return new HtmlElem("input")
            .withAttr("type", type)
            .withAttr("name", name);
    }

    public static Writable ul(Writable... c) {
        return new HtmlElem("ul",c);
    }
    public static Writable li(Writable...c) {
        return new HtmlElem("li",c);
    }

    public static Writable table(Writable...c) {
    	return new HtmlElem("table",c);
    }

    public static Writable tr(Writable...c) {
    	return new HtmlElem("tr",c);
    }

    public static Writable th(Writable...c) {
    	return new HtmlElem("th",c);
    }

    public static Writable td(Writable...c) {
    	return new HtmlElem("td",c);
    }
    public static Writable a(String href, String t) {
        return new HtmlElem("a", text(t))
            .withAttr("href", href);
    }
    public static Writable a(String href, int t) {
        return new HtmlElem("a", text(t))
            .withAttr("href", href);
    }

    protected static Writable goInit() {
		HtmlElem h3 = new HtmlElem("h3");
		h3.withContent(
				li(a("/","NJ Rentals")));
		return h3;
	}
    protected static Writable goBack(String path, String name) {
		HtmlElem h3 = new HtmlElem("h3");
		h3.withContent(
				li(a(path,name)));
		return h3;
	}

    public static Writable br()
    {
    	HtmlElem br = new HtmlElem("br");
    	return br;
    }
    public static Writable b(Writable...c)
    {
    	HtmlElem b = new HtmlElem("b", c);
    	return b;
    }

}


text:
#region Copyright
// -----------------------------------------------------------------------
//
// Copyright (c) 2012, Shad Storhaug <shad@shadstorhaug.com>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------
#endregion

namespace ContinuousSeo.W3cValidation.Runner.UrlProcessors
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    public class UrlProcessorFactory : IUrlProcessorFactory
    {
        private readonly UrlProcessor mXmlProcessor;
        private readonly UrlProcessor mHtmlProcessor;

        public UrlProcessorFactory(
            UrlProcessor xmlProcessor,
            UrlProcessor htmlProcessor)
        {
            if (xmlProcessor == null)
                throw new ArgumentNullException("xmlProcessor");
            if (htmlProcessor == null)
                throw new ArgumentNullException("htmlProcessor");

            this.mXmlProcessor = xmlProcessor;
            this.mHtmlProcessor = htmlProcessor;
        }

        #region IUrlProcessorFactory Members

        public UrlProcessor GetUrlProcessor(string outputFormat)
        {
            outputFormat = (string.IsNullOrEmpty(outputFormat)) ? string.Empty : outputFormat.ToLowerInvariant();
            switch (outputFormat)
            {
                case "xml":
                    return this.mXmlProcessor;
                default:
                    return this.mHtmlProcessor;
            }
        }

        #endregion
    }
}


text:
C
C+cal_open
C
      subroutine cal_open( psf_name, lsf_key, s )

C     Asks the user to select an existing calibration to open.
C
C     Given:
C         Physical sample file name
              character*(*)       psf_name

C     Returned:
C         Key of LSF used in calibration (unchanged if not same sf.)
              integer             lsf_key
C         Status variable - must be zero on entry - otherwise error
              integer             s
C
C-
C
C     Function declarations
C
      include        '/mrao/include/chrlib_functions.inc'
      include        '/mrao/include/iolib_functions.inc'

C
C     Global includes -
C         ( i.e. Global constant, variable and common declarations )
C
      include        '/mrao/include/iolib_errors.inc'
      include        '/mrao/post/include/cal_common.inc'

C
C     Local variables, equivalences and commons
C         Loop counter
              integer         i
C         Calibration file name
              character*64    cal_file_name
C         Number of removes in calibration file
              integer         num_cals
C         General purpose file unit number.
              integer         lun
C         Calibration name
              character*20    source
C         Flag set if current calibration is the one wanted.
              logical         found

C     ==================================================================
C
C     Subroutine initialisation
C     -------------------------
C
C     Check for non zero entry status
      if ( s .ne. 0 ) return

      call open_sf( lun, psf_name, 'READ', 0, s )
      call enq_namfil( lun, 'CAL', cal_file_name, s )
      if (s .eq. NO_FILE) then
          s = 0
          call io_wrout(
     *             'No calibrations have been saved for this file.')
          call close_sf( lun, s )
          return
      else
          call close_sf( lun, s )
      end if

C
C     Main Code
C     ---------
C
      call open_sf( lun, cal_file_name, 'READ', 0, s )
      call enq_numsrc( lun, num_cals, s )

      i = 1
      found = .false.
  100 continue
          call enq_src_name( lun, i, source, s )
          if ( io_yesno( 'Open calibration on '//source//' ? ',
     *                'No', s                                   )) then
              found = .true.
              call enq_src_def( lun, i, cal_record, s )
              cal_number = i
          else
              i = i + 1
          end if
      if ( i.le.num_cals .and. s.eq.0 .and. .not.found ) goto 100

C     Restore status for user break.
      if ( s .eq. usr_break ) s = 0
      call close_sf( lun, s )
      if (chr_fmatch( cal_sf, psf_name )) lsf_key = cal_lsf

      if ( s .ne. 0 ) goto 9999
      return

C
C     Error Handling
C     --------------
C
 9999 continue
          call cal_wrerr( s, 'in subroutine cal_open')
          return
      end


text:
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />

	<link rel="stylesheet" type="text/css" href="../../mercury.css">

	<title>Mercury Demo</title>

	<link rel="stylesheet" type="text/css" href="style.css">

Mercury Version

Editable region

Editable region

		If the first line of content isn't wrapped in an element you can't set justification (mozilla only bug).

text with a meta tag (that will be removed)

		123<meta>editable content

anchor with a div inside

		l
ink with a div in
 it

image wrapped in an anchor

		123

table with header and definition cells

					R1C1
					R1C2

					R2C1
					R2C2
					R2C3
					R2C4
					R2C5

					R3C1
					R3C2
					R3C3

					R4C1
					R4C2
					R4C3
					R4C4
					R4C5

					R5C1
					R5C2
					R5C3
					R5C4

					R6C1
					R6C2
					R6C3
					R6C4

					R7C1
					R7C2
					R7C3

					R8C1
					R7C2

table without tbody or border

				R1C1
				R1C2

				R2C1
				R2C2
				R2C3

				R3C1
				R3C2

fixed width table (column where all colspans > 1, row where all rowspans > 1)

					R1C1
					R1C2

					R3C1
					R3C2

					R4C1
					R4C3

paragraph with an overline wrapped in an underline

123 under overline line 123

paragraph with an underline wrapped in an overline

123 over underline line 123

style tag that styles images with a border

image next to content wrapped in an anchor

		link for #bookmark1

snippet that's pre-loaded

snippet1

bookmark links

		Bookmark1
Bookmark2

		Additional content not wrapped in anything

youtube and vimeo iframes with content surrounding it

		123123321
		123

Markupable region (with markdown)

## notes ##
**whitespace** in markupable regions is _important_.

## ordered list ##
1. list item 1
2. list item 2

## unordered list ##
- list item 1
- list item 2

## horizontal rule ##
- - -

## anchor ##
[this is a link](foo 'optional title')

## image ##
![add alt text](../../images/clippy.png)

## snippet that's pre-loaded ##
[--snippet_2--]

## code ##
	this html will not be escaped
								 and		 whitespace		 will be retained

## blockquote ##
> this is indented one level

## paragraph with bold, italics, etc. ##
Turkey corned beef ham, chuck ham hock **venison _drumstick_ ** tongue ribeye. Beef tongue pancetta, short ribs meatball headcheese jowl bacon swine t-bone shoulder venison. Hamburger short loin turkey flank short ribs tail. Chicken tri-tip sausage, bresaola sirloin turkey hamburger headcheese shank rump. Pork ground round t-bone, ham hock sirloin biltong chicken fatback pork belly pastrami pancetta jowl tail. Cow ribeye pork chop, flank sirloin tail short loin pork loin chicken boudin pastrami. Boudin chuck shankle, spare ribs pancetta fatback bresaola.

Snippetable region

snippet3

snippet4

snippet5

snippet6

snippet7

snippet8

snippet9

snippet10

Editable region (single snippet and no content)

snippet11

Editable region (fixed width/height and overflow)

		wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Snippetable region (iframe snippet that contains flash)

snippet12

snippet13


text:
package net.zomis.minesweeper.analyze.detail;

import net.zomis.minesweeper.analyze.FieldGroup;
import net.zomis.minesweeper.analyze.GroupValues;

public interface ProbabilityKnowledge<T> {

	/**
	 * @return The field that this object has stored the probabilities for
	 */
	T getField();

	/**
	 * @return The {@link FieldGroup} for the field returned by {@link #getField()}
	 */
	FieldGroup<T> getFieldGroup();

	/**
	 * @return How many mines has already been found for this field
	 */
	int getFound();

	/**
	 * @return The mine probability for the {@link FieldGroup} returned by {@link #getFieldGroup()}
	 */
	double getMineProbability();

	/**
	 * @return {@link GroupValues} object for what neighbors the field returned by {@link #getField()} has
	 */
	GroupValues<T> getNeighbors();

	/**
	 * @return The array of the probabilities for what number this field has. The sum of this array + the value of {@link #getMineProbability()} will be 1.
	 */
	double[] getProbabilities();

}


text:
<?php

namespace ExchangeRatesWebsite\Tests\Web;

use Silex\Application;
use Silex\WebTestCase as BaseWebTestCase;
use Symfony\Component\BrowserKit\Client;

abstract class WebTestCase extends BaseWebTestCase
{
    /**
     * @var Client
     */
    protected $client;

    public function setUp()
    {
        parent::setUp();
        $this->client = $this->createClient();
    }

    /**
     * @return Application
     */
    public function createApplication()
    {
        $app = require __DIR__.'/../../../../src/app.php';
        $app['debug'] = true;
        $app['exception_handler']->disable();

        return $app;
    }
}


text:
NAMESPACE_BEGIN(CryptoPP)

RandomPool::RandomPool()
	: m_pCipher(new AES::Encryption), m_keySet(false)
{
	memset(m_key, 0, m_key.SizeInBytes());
	memset(m_seed, 0, m_seed.SizeInBytes());
}

void RandomPool::IncorporateEntropy(const byte *input, size_t length)
{
	SHA256 hash;
	hash.Update(m_key, 32);
	hash.Update(input, length);
	hash.Final(m_key);
	m_keySet = false;
}

void RandomPool::GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword size)
{
	if (size > 0)
	{
		if (!m_keySet)
			m_pCipher->SetKey(m_key, 32);

		CRYPTOPP_COMPILE_ASSERT(sizeof(TimerWord) <= 16);
		CRYPTOPP_COMPILE_ASSERT(sizeof(time_t) <= 8);

		Timer timer;
		TimerWord tw = timer.GetCurrentTimerValue();

		*(TimerWord *)(void*)m_seed.data() += tw;
		time_t t = time(NULL);

		// UBsan finding: signed integer overflow: 1876017710 + 1446085457 cannot be represented in type 'long int'
		// *(time_t *)(m_seed.data()+8) += t;
		word64 tt1 = 0, tt2 = (word64)t;
		memcpy(&tt1, m_seed.data()+8, 8);
		memcpy(m_seed.data()+8, &(tt2 += tt1), 8);

		// Wipe the intermediates
		*((volatile TimerWord*)&tw) = 0;
		*((volatile word64*)&tt1) = 0;
		*((volatile word64*)&tt2) = 0;

		do
		{
			m_pCipher->ProcessBlock(m_seed);
			size_t len = UnsignedMin(16, size);
			target.ChannelPut(channel, m_seed, len);
			size -= len;
		} while (size > 0);
	}
}

NAMESPACE_END

#endif