Regression

osx-64 / Tests-osx-64 / MacOSX64.Zinc.Tests.ZnServerTest.testRequestLineTooLong (from Zinc-Tests)

Stacktrace

TestTookTooMuchTime
Process>>pvtSignal:list:
[self schedule.
	"It is critical that the following has no suspension point so that
	the test and the wait primitive are atomic. In addition, if the delay
	is no longer being waited on while entering the way we know that it 
	is expired because the delay has already fired."
	beingWaitedOn 
		ifTrue:[delaySemaphore wait]
		ifFalse:[expired := true]] in DelayWaitTimeout>>wait
FullBlockClosure(BlockClosure)>>ensure:
DelayWaitTimeout>>wait
Semaphore>>waitTimeoutMSecs:
Socket>>waitForDataFor:ifClosed:ifTimedOut:
Socket>>waitForDataFor:
ZdcSocketStream(ZdcAbstractSocketStream)>>socketWaitForData
[ self socketWaitForData ] in ZdcSocketStream(ZdcSimpleSocketStream)>>fillReadBuffer
FullBlockClosure(BlockClosure)>>on:do:
ZdcSocketStream(ZdcSimpleSocketStream)>>fillReadBuffer
ZdcSocketStream(ZdcAbstractSocketStream)>>next
ZnLineReader>>processNext
ZnLineReader>>nextLine
ZnStatusLine>>readFrom:
ZnStatusLine class>>readFrom:
ZnResponse>>readHeaderFrom:
ZnResponse(ZnMessage)>>readFrom:
ZnResponse class(ZnMessage class)>>readFrom:
[ :stream | ZnResponse readFrom: stream ] in ZnClient>>reader
[ self reader value: connection ] in [
			response := (#(HEAD CONNECT) includes: request method)
				ifTrue: [ ZnResponse readHeaderFrom: connection ]
				ifFalse: [ 
					self streaming
						ifTrue: [ ZnResponse readStreamingFrom: connection ]
						ifFalse: [ 
							self withMaximumEntitySizeDo: [ self reader value: connection ] ] ] ] in [
		self withDefaultCharacterEncoderDo: [
			response := (#(HEAD CONNECT) includes: request method)
				ifTrue: [ ZnResponse readHeaderFrom: connection ]
				ifFalse: [ 
					self streaming
						ifTrue: [ ZnResponse readStreamingFrom: connection ]
						ifFalse: [ 
							self withMaximumEntitySizeDo: [ self reader value: connection ] ] ] ] ] in ZnClient>>readResponse
True>>ifTrue:ifFalse:
ZnClient>>withMaximumEntitySizeDo:
[
			response := (#(HEAD CONNECT) includes: request method)
				ifTrue: [ ZnResponse readHeaderFrom: connection ]
				ifFalse: [ 
					self streaming
						ifTrue: [ ZnResponse readStreamingFrom: connection ]
						ifFalse: [ 
							self withMaximumEntitySizeDo: [ self reader value: connection ] ] ] ] in [
		self withDefaultCharacterEncoderDo: [
			response := (#(HEAD CONNECT) includes: request method)
				ifTrue: [ ZnResponse readHeaderFrom: connection ]
				ifFalse: [ 
					self streaming
						ifTrue: [ ZnResponse readStreamingFrom: connection ]
						ifFalse: [ 
							self withMaximumEntitySizeDo: [ self reader value: connection ] ] ] ] ] in ZnClient>>readResponse
True>>ifTrue:ifFalse:
ZnClient>>withDefaultCharacterEncoderDo:
[
		self withDefaultCharacterEncoderDo: [
			response := (#(HEAD CONNECT) includes: request method)
				ifTrue: [ ZnResponse readHeaderFrom: connection ]
				ifFalse: [ 
					self streaming
						ifTrue: [ ZnResponse readStreamingFrom: connection ]
						ifFalse: [ 
							self withMaximumEntitySizeDo: [ self reader value: connection ] ] ] ] ] in ZnClient>>readResponse
True>>ifTrue:ifFalse:
ZnClient>>withMaximumNumberOfDictionaryEntriesDo:
ZnClient>>readResponse
ZnClient>>executeRequestResponse
[ self executeRequestResponse ] in ZnClient>>getConnectionAndExecute
FullBlockClosure(BlockClosure)>>ensure:
ZnClient>>getConnectionAndExecute
ZnClient>>executeWithRedirectsRemaining:
[ self executeWithRedirectsRemaining: self maxNumberOfRedirects ] in ZnClient>>executeWithRetriesRemaining:
FullBlockClosure(BlockClosure)>>on:do:
ZnClient>>executeWithRetriesRemaining:
[ self executeWithRetriesRemaining: self numberOfRetries ] in [ 
		[ self executeWithRetriesRemaining: self numberOfRetries ]
			on: Error
			do: self ifFailBlock ] in ZnClient>>executeWithTimeout
FullBlockClosure(BlockClosure)>>on:do:
[ 
		[ self executeWithRetriesRemaining: self numberOfRetries ]
			on: Error
			do: self ifFailBlock ] in ZnClient>>executeWithTimeout
[ ^ block value ] in ZnClient>>withTimeoutDo:
[ activeProcess
			psValueAt: index
			put: anObject.
		aBlock value ] in ZnConnectionTimeout(DynamicVariable)>>value:during:
FullBlockClosure(BlockClosure)>>ensure:
ZnConnectionTimeout(DynamicVariable)>>value:during:
ZnConnectionTimeout class(DynamicVariable class)>>value:during:
ZnClient>>withTimeoutDo:
ZnClient>>executeWithTimeout
[ result := self executeWithTimeout ] in ZnClient>>execute
[ ^ block value ] in ZnClient>>withProgressDo:
[ activeProcess
			psValueAt: index
			put: anObject.
		aBlock value ] in ZnSignalProgress(DynamicVariable)>>value:during:
FullBlockClosure(BlockClosure)>>ensure:
ZnSignalProgress(DynamicVariable)>>value:during:
ZnSignalProgress class(DynamicVariable class)>>value:during:
ZnClient>>withProgressDo:
ZnClient>>execute
ZnClient>>get
ZnEasy class>>get:
ZnServerTest>>assertRequestLineTooLong:
[ :server |
		self deny: server debugMode.
		self assertRequestLineTooLong: server localUrl ] in [
		self withServerDo: [ :server |
		self deny: server debugMode.
		self assertRequestLineTooLong: server localUrl ] ] in ZnServerTest>>testRequestLineTooLong
FullBlockClosure(BlockClosure)>>cull:
[ 
		server start.
		self 
			assert: server isRunning & server isListening
			description: ('Failed to start server on port {1}. Is there one already?' format: { server port }).
		block cull: server 
	] in ZnServerTest>>withServerDo:
FullBlockClosure(BlockClosure)>>ensure:
ZnServerTest>>withServerDo:
[
		self withServerDo: [ :server |
		self deny: server debugMode.
		self assertRequestLineTooLong: server localUrl ] ] in ZnServerTest>>testRequestLineTooLong
FullBlockClosure(BlockClosure)>>ensure:
ZnServerTest>>usingClassicSocketStreamsOnWindowsDo:
ZnServerTest>>testRequestLineTooLong
ZnServerTest(TestCase)>>performTest