// $Header: /home/cvs/jakarta-jmeter/src/protocol/http/org/apache/jmeter/protocol/http/util/HTTPArgument.java,v 1.13 2004/02/12 00:29:50 sebb Exp $
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* 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.
*
*/
package org.apache.jmeter.protocol.http.util;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.LinkedList;
import java.util.List;
import junit.framework.TestCase;
import org.apache.jmeter.config.Argument;
import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.testelement.property.BooleanProperty;
import org.apache.jmeter.testelement.property.CollectionProperty;
import org.apache.jmeter.testelement.property.PropertyIterator;
import org.apache.jorphan.util.JOrphanUtils;
/*
*
* @author unattributed
* @version $Revision: 1.13 $ $Date: 2004/02/12 00:29:50 $
*/
public class HTTPArgument extends Argument implements Serializable
{
private static final String ALWAYS_ENCODE = "HTTPArgument.always_encode";
private static final String USE_EQUALS = "HTTPArgument.use_equals";
private static EncoderCache cache = new EncoderCache(1000);
/**
* Constructor for the Argument object.
*/
public HTTPArgument(String name, String value, String metadata)
{
this(name, value, false);
this.setMetaData(metadata);
}
public void setUseEquals(boolean ue)
{
if(ue)
{
setMetaData("=");
}
else
{
setMetaData("");
}
setProperty(new BooleanProperty(USE_EQUALS,ue));
}
public boolean isUseEquals()
{
boolean eq = getPropertyAsBoolean(USE_EQUALS);
if (getMetaData().equals("=")
|| (getValue() != null && getValue().toString().length() > 0))
{
setUseEquals(true);
return true;
}
return eq;
}
public void setAlwaysEncoded(boolean ae)
{
setProperty(new BooleanProperty(ALWAYS_ENCODE, ae));
}
public boolean isAlwaysEncoded()
{
return getPropertyAsBoolean(ALWAYS_ENCODE);
}
/**
* Constructor for the Argument object.
*/
public HTTPArgument(String name, String value)
{
this(name, value, false);
}
public HTTPArgument(String name, String value, boolean alreadyEncoded)
{
setAlwaysEncoded(true);
if (alreadyEncoded)
{
try
{
name = JOrphanUtils.decode(name, "UTF-8");
value = JOrphanUtils.decode(value.toString(), "UTF-8");
}
catch (UnsupportedEncodingException e)
{
// UTF-8 unsupported? You must be joking!
log.error("UTF-8 encoding not supported!");
throw new Error(e.toString());
}
}
setName(name);
setValue(value);
setMetaData("=");
}
public HTTPArgument(
String name,
String value,
String metaData,
boolean alreadyEncoded)
{
this(name, value, alreadyEncoded);
setMetaData(metaData);
}
public HTTPArgument(Argument arg)
{
this(arg.getName(), arg.getValue(), arg.getMetaData());
}
/**
* Constructor for the Argument object
*/
public HTTPArgument()
{}
/**
* Sets the Name attribute of the Argument object.
*
* @param newName the new Name value
*/
public void setName(String newName)
{
if (newName == null || !newName.equals(getName()))
{
super.setName(newName);
}
}
public String getEncodedValue()
{
if (isAlwaysEncoded())
{
return cache.getEncoded(getValue());
}
else
{
return getValue();
}
}
public String getEncodedName()
{
if (isAlwaysEncoded())
{
return cache.getEncoded(getName());
}
else
{
return getName();
}
}
public static void convertArgumentsToHTTP(Arguments args)
{
List newArguments = new LinkedList();
PropertyIterator iter = args.getArguments().iterator();
while (iter.hasNext())
{
Argument arg = (Argument) iter.next().getObjectValue();
if (!(arg instanceof HTTPArgument))
{
newArguments.add(new HTTPArgument(arg));
}
else
{
newArguments.add(arg);
}
}
args.removeAllArguments();
args.setArguments(newArguments);
}
public static class Test extends TestCase
{
public Test(String name)
{
super(name);
}
public void testCloning() throws Exception
{
HTTPArgument arg = new HTTPArgument("name.?", "value_ here");
assertEquals("name.%3F", arg.getEncodedName());
assertEquals("value_+here", arg.getEncodedValue());
HTTPArgument clone = (HTTPArgument) arg.clone();
assertEquals("name.%3F", clone.getEncodedName());
assertEquals("value_+here", clone.getEncodedValue());
}
public void testConversion() throws Exception
{
Arguments args = new Arguments();
args.addArgument("name.?", "value_ here");
args.addArgument("name$of property", "value_.+");
HTTPArgument.convertArgumentsToHTTP(args);
CollectionProperty argList = args.getArguments();
HTTPArgument httpArg =
(HTTPArgument) argList.get(0).getObjectValue();
assertEquals("name.%3F", httpArg.getEncodedName());
assertEquals("value_+here", httpArg.getEncodedValue());
httpArg = (HTTPArgument) argList.get(1).getObjectValue();
assertEquals("name%24of+property", httpArg.getEncodedName());
assertEquals("value_.%2B", httpArg.getEncodedValue());
}
}
}