JetBrains.TeamCity.ServiceMessages Indicates that marked element should be localized or not. Initializes a new instance of the class. true if a element should be localized; otherwise, false. Returns whether the value of the given object is equal to the current . The object to test the value equality of. true if the value of the given object is equal to that of the current; otherwise, false. Returns the hash code for this instance. A hash code for the current . Gets a value indicating whether a element should be localized. true if a element should be localized; otherwise, false. Indicates that marked method builds string by format pattern and (optional) arguments. Parameter, which contains format string, should be given in constructor. The format string should be in -like form Initializes new instance of StringFormatMethodAttribute Specifies which parameter of an annotated method should be treated as format-string Gets format parameter name Indicates that the function argument should be string literal and match one of the parameters of the caller function. For example, has such parameter. Indicates that the marked method is assertion method, i.e. it halts control flow if one of the conditions is satisfied. To set the condition, mark one of the parameters with attribute Indicates the condition parameter of the assertion method. The method itself should be marked by attribute. The mandatory argument of the attribute is the assertion type. Initializes new instance of AssertionConditionAttribute Specifies condition type Gets condition type Specifies assertion type. If the assertion method argument satisifes the condition, then the execution continues. Otherwise, execution is assumed to be halted Indicates that the marked parameter should be evaluated to true Indicates that the marked parameter should be evaluated to false Indicates that the marked parameter should be evaluated to null value Indicates that the marked parameter should be evaluated to not null value Indicates that the marked method unconditionally terminates control flow execution. For example, it could unconditionally throw exception Indicates that the value of marked element could be null sometimes, so the check for null is necessary before its usage Indicates that the value of marked element could never be null Indicates that the value of marked type (or its derivatives) cannot be compared using '==' or '!=' operators. There is only exception to compare with null, it is permitted When applied to target attribute, specifies a requirement for any type which is marked with target attribute to implement or inherit specific type or types [BaseTypeRequired(typeof(IComponent)] // Specify requirement internal class ComponentAttribute : Attribute {} [Component] // ComponentAttribute requires implementing IComponent interface internal class MyComponent : IComponent {} Initializes new instance of BaseTypeRequiredAttribute Specifies which types are required Gets enumerations of specified base types Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), so this symbol will not be marked as unused (as well as by other usage inspections) Gets value indicating what is meant to be used Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes as unused (as well as by other usage inspections) Gets value indicating what is meant to be used Only entity marked with attribute considered used Indicates implicit assignment to a member Indicates implicit instantiation of a type with fixed constructor signature. That means any unused constructor parameters won't be reported as such. Indicates implicit instantiation of a type Specify what is considered used implicitly when marked with or Members of entity marked with attribute are considered used Entity marked with attribute and all its members considered used This attribute is intended to mark internally available API which should not be removed and so is treated as used. Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. If the parameter is delegate, indicates that delegate is executed while the method is executed. If the parameter is enumerable, indicates that it is enumerated while the method is executed. Indicates that method doesn't contain observable side effects. The same as Object representation of TeamCity service message Return a value for keys or null Key to check for value value of available or null Service message name, i.e. messageName in ##teamcity[messageName 'ddd']. For one-value service messages returns value, i.e. 'aaa' for ##teamcity[message 'aaa'] or null otherwise, i.e. ##teamcity[message aa='aaa'] Emptry for one-value service messages, i.e. ##teamcity[message 'aaa'], returns all keys otherwise Provides service messages parsing from stream Lazy parses service messages from string text to parse enumerable of service messages Reads stream parsing service messages from it. stream to parse. Stream will not be closed Iterator of service messages Provides service messages parsing from stream Lazy parses service messages from string text to parse enumerable of service messages Reads stream parsing service messages from it. stream to parse. Stream will not be closed Iterator of service messages Performs TeamCity-format escaping of a string. Performs TeamCity-format escaping of a string. Provides service messages serialization for most cases Serializes single value service message message name value service message string Serializes single value service message message name anonymous object containing all service message parameters service message string Serializes single value service message message name params array of service message properties service message string Serializes single value service message message name params of service message properties service message string Serializes service message Serializes service message from IDictionary service message name arguments Helper class to create complex service message. Use object initilizer to simplify code, i.e. new ServiceMessage("buildProblem") { { "identity", identity}, {"description", message}} Copy constructor service message to copy from Simple constructor service message name Provides service messages serialization for most cases Serializes single value service message message name value service message string Serializes single value service message message name anonymous object containing all service message parameters service message string Serializes single value service message message name params array of service message properties service message string Serializes service message parser service message Serializes service message from IDictionary service message name arguments Serializes single value service message message name params of service message properties service message string Object to represent service message attributes Key Value Constructor of service message attribute service message key, must not contain escapable symbols, not null value, notnull Helper class to generate FlowIds Generates new unique FlowId next generated flow id Helper class to generate FlowIds Generates new unique FlowId Helper implementation of IServiceMessage Simple implementation of ServiceMessage Abstract service message acceptor Accepts new service message. Default implementation may simply prtint service message to console service message to process Servivce message acceptor implementation with support of IServiceMessageUpdater chains FlowId aware implementation of ServiceMessagesProcessor Creates new ServiceMessage updater that uses specified FlowId Current flow Id Creates generic processor that calls messages updaters and sends output to provided deledate. writer of service messages objects flow id generator that is called to create next flowId service message updaters, i.e. timestamp updater Creates new ServiceMessage updater that uses specified FlowId Specialized service messages writer facade. Contains all methods for generating different service messages. Do not forget to dispose this interface after you finished using it. To get the instance of the interface, call new JetBrains.TeamCity.ServiceMessages.Write.Special.TeamCityServiceMessages().CreateWriter Implementation is not thread-safe. Create an instance for each thread instead. Generates pair of service messages to open/close block, for example: 
##teamcity[blockOpened name='<blockName>']
and 
##teamcity[blockClosed name='<blockName>']
http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-BlocksofServiceMessages Implementation is not thread-safe. Create an instance for each thread instead. Generates open block message. To close the block, call Dispose to the given handle block name to report Starts another flowId reporting starting. This call would emmit 
##teamcity[flowStarted flowId='%lt;new flow id>' parent='current flow id']
and 
##teamcity[flowFinished flowId='%lt;new flow id>']
on writer dispose Implementation is not thread-safe. Create an instance for each thread instead. Generates start flow message and returns disposable object to close flow Add a build log entry message 
            ##teamcity[message text='<message text>' errorDetails='<error details>' status='<status value>']
http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ReportingMessagesForBuildLog Implementation is not thread-safe. Create an instance for each thread instead. Writes normal message text Writes warning message text Writes error message with details text error details This interface provides writers for test messages. All, but test ignore messages are required to be reported from 
##teamcity[testStarted name='testname']
and 
##teamcity[testFinished name='testname' duration='<test_duration_in_milliseconds>']
messages. All tests reportings are done form this method. Implementation is not thread-safe. Create an instance for each thread instead. TeamCity tests loggin in done in test suites. To be able to logs tests you first need to open suite Opens tests suite with give name 
##teamcity[testSuiteStarted name='suite.name']
To close suite, call Dispose method of a returned logger. suite name test logger. To start reporting a test, call OpenTest method. To stop reporing test call Dispose on the given object test name to be reported test output/status reporting handle Introduces compilation block. 
##teamcity[compilationStarted compiler='<compiler name>']
and 
##teamcity[compilationFinished compiler='<compiler name>']
http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ReportingCompilationMessages Implementation is not thread-safe. Create an instance for each thread instead. Generates open compilation block. To close block call Dispose to the given handle Service messages for dynamically publish artifacts. http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-PublishingArtifactswhiletheBuildisStillinProgress Implementation is not thread-safe. Create an instance for each thread instead. attaches new artifact publishing rules as described in http://confluence.jetbrains.net/display/TCD7/Build+Artifact Interface for writing build-related messages http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity#BuildScriptInteractionwithTeamCity-ReportingBuildNumber Implementation is not thread-safe. Create an instance for each thread instead. Generates service message to update build number. Generates build problem service message problem unique identity, no more than 60 chars problem message Generates service message to update build parameter http://confluence.jetbrains.net/display/TCD7/Configuring+Build+Parameters parameter name, could start with env. for environment, system. for system property, otherwise it would be config parameter value Generates service message to report build statistics values http://confluence.jetbrains.net/display/TCD7/Customizing+Statistics+Charts#CustomizingStatisticsCharts-customCharts statistics report key statistics report values Allows to send bare service message message to send Represents information about currently openned child blocks or tests or test suites. This method performs check if no child blocks are opennd. It is used to check if it is allowed to use current I*Writer Service message updater that adds FlowId to service message according to http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity Base interface for service message updaters Thus method is called to update service message instance. service message updated service message Custructs updater flowId set to all messages Creates flow id from given generator instance Service message updater that adds Timestamp to service message according to http://confluence.jetbrains.net/display/TCD7/Build+Script+Interaction+with+TeamCity Sub inteface for created tests writer for some parent test suite. Writer interface for generating test information service messages Attaches test output to the test test output Attaches test error output to the test error output Marks test as ignored test ignore reason Marks test as ignored Marks test as failed. short error message detailed error information, i.e. stacktrace This method can be called only once. Specifies test duration TeamCity may compute test duration inself, to provide precise data, you may set the duration explicitly time of test Factory interface for specialized service messages generation Create instance of to get the implementation of the interface. Created writer that generates service messages to a Console.Out Implementation does not support multiple-threads. If you need to log more me Creates writer that translates service messages to the given delegate. generated service messages processor Adds user-specific service message updater to the list of service message updaters. updater instance Basic implementation of TeamCity service message generation facade Most specific constructor. Could be used with DI