<!--
 ~ Licensed to the Apache Software Foundation (ASF) under one
 ~ or more contributor license agreements.  See the NOTICE file
 ~ distributed with this work for additional information
 ~ regarding copyright ownership.  The ASF licenses this file
 ~ to you 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.
 -->
<ivy-module version="2.0">
  <info organisation="apache-cassandra" module="cassandra"/>

  <dependencies>
    <!-- for Hadoop unit tests -->
    <dependency org="commons-logging" name="commons-logging" rev="1.1.1"/>

    <!-- FIXME: paranamer can be dropped after we're depending on avro 
    (since it depends on them). -->
    <dependency org="com.thoughtworks.paranamer"
                name="paranamer-ant" rev="2.1"/>
    <dependency org="junit" name="junit" rev="4.6" />
    <dependency org="org.apache.rat" name="apache-rat" rev="0.6" />

    <dependency org="net.java.dev.jna" name="jna" rev="3.2.7"/>
  </dependencies>
</ivy-module>

